diff --git a/packages/eql/.gitattributes b/packages/eql/.gitattributes
index cb53a3516..dc8060fd3 100644
--- a/packages/eql/.gitattributes
+++ b/packages/eql/.gitattributes
@@ -8,6 +8,8 @@
 #     and drift-gated by `mise run codegen:parity`. (The hand-written
 #     src/v3/scalars/functions.sql and *_extensions.sql are NOT generated and
 #     are deliberately left unmarked.)
+#   - src/v3/scalars/ore_fallback.sql : the one generated file directly under
+#     src/v3/scalars, outside the per-type directories the globs above match.
 #   - tests/sqlx/snapshots/*_expanded.rs : `cargo expand` snapshots of the
 #     scalar matrix macros (the start_line/end_line churn is location drift).
 #   - tests/sqlx/snapshots/matrix_tests*.txt : matrix-coverage inventory pinned
@@ -19,6 +21,7 @@ src/v3/scalars/*/*_types.sql linguist-generated
 src/v3/scalars/*/*_functions.sql linguist-generated
 src/v3/scalars/*/*_operators.sql linguist-generated
 src/v3/scalars/*/*_aggregates.sql linguist-generated
+src/v3/scalars/ore_fallback.sql linguist-generated
 tests/sqlx/snapshots/*_expanded.rs linguist-generated
 tests/sqlx/snapshots/matrix_tests*.txt linguist-generated
 
diff --git a/packages/eql/.gitignore b/packages/eql/.gitignore
index d7ce9d61a..60e72f5a6 100644
--- a/packages/eql/.gitignore
+++ b/packages/eql/.gitignore
@@ -260,3 +260,7 @@ nextest.tar.zst
 docs/decisions/2026-06-10-eql-v3-json-type-kind.md
 docs/handoff/2026-06-10-v3-jsonb-fixture-alignment.md
 .claude/
+
+# Rendered SQL per EQL version, written by tasks/build.sh from the placeholder
+# source (ADR-0002). Anchored: tasks/build/ is tracked.
+/build/
diff --git a/packages/eql/AGENTS.md b/packages/eql/AGENTS.md
index b6e5e1929..28b56e997 100644
--- a/packages/eql/AGENTS.md
+++ b/packages/eql/AGENTS.md
@@ -42,6 +42,21 @@ This project uses `mise` for task management. Common commands:
   - `cipherstash-encrypt.sql` - The sole installer: the self-contained `eql_v3` surface, globbed from `src/v3` only (no `eql_v2`; installable into a DB with no `eql_v2` present)
   - `cipherstash-encrypt-uninstall.sql` - Matching uninstaller
 
+#### Schema and version placeholders
+
+The SQL source never names its schemas or its payload version literally. It writes two placeholders, and the build renders the one source once per EQL version (ADR-0002, `docs/adr/0002-*` at the repo root):
+
+| placeholder | rendered for `eql_v3` | rendered for `eql_v4` |
+|---|---|---|
+| `{{prefix}}` | `eql_v3` | `eql_v4` |
+| `{{eql_version}}` | `3` | `4` |
+
+`{{prefix}}` is the schema and the start of every other name: `{{prefix}}.eq_term`, `{{prefix}}_internal.hmac_256`, `public.{{prefix}}_text_eq`. `{{eql_version}}` appears in every domain CHECK: `VALUE->>'v' = '{{eql_version}}'`. This covers every file under `src/v3/` (hand-written and generated), `src/v3/version.template`, `tasks/pin_search_path_v3.sql` and `tasks/uninstall-v3.sql`. The generator emits the placeholders too: `SCHEMA`, `INTERNAL_SCHEMA`, `PUBLIC_TYPNAME_PREFIX` and `EQL_VERSION` in `crates/eql-codegen/src/consts.rs` are placeholder strings. The Rust bindings are the exception. They describe v3 payloads and keep `eql_domains::PUBLIC_TYPNAME_PREFIX`, the literal `eql_v3_`.
+
+`tasks/build.sh` renders the ordered source into `build/render/eql_v3/` (gitignored, same relative paths) with `eql-codegen render`, runs the symbol-order and installer-completeness gates on the rendered files, and assembles `release/` from them. The renderer refuses three things: an unknown placeholder, an unterminated `{{`, and a **literal `eql_v3` or `eql_v4`** anywhere in the source, comments included. A literal name renders identically for both versions, so the v4 bundle would reach into v3. Write the placeholder in prose too.
+
+Anything that needs the source as real SQL reads the rendered tree, not `src/`: `docs:validate:documented-sql` runs psql over `build/render/eql_v3/src`, and the Doxygen input filter (`tasks/docs/doxygen-filter.sh`) renders `eql_v3` names on the fly. A new tool that parses `src/v3` must do one or the other.
+
 There are no longer separate Main / Supabase / Protect / v3-only build variants. The combined `eql_v2` build that previously produced multiple artefacts has been removed; the v3 surface now ships as one self-contained installer under the canonical `cipherstash-encrypt.sql` name (`eql-codegen order` walks `src/v3` only). Because the surface owns no `eql_v2` dependency, it is already Supabase / managed-Postgres compatible (functional indexes over extractors, no superuser-only operator classes) without a dedicated subset build. Self-containment — no `-- REQUIRE:` edge pointing outside `src/v3`, no `eql_v2.<symbol>` anywhere in the surface — is enforced at build time by `surface_order`'s `OutsideSurface` error (`crates/eql-codegen/src/ordering.rs`) and CI-gated by `mise run test:self_contained_v3`.
 
 ## Project Architecture
diff --git a/packages/eql/crates/eql-codegen/src/bindings.rs b/packages/eql/crates/eql-codegen/src/bindings.rs
index d785beccf..ce50f07a1 100644
--- a/packages/eql/crates/eql-codegen/src/bindings.rs
+++ b/packages/eql/crates/eql-codegen/src/bindings.rs
@@ -83,6 +83,13 @@ fn capability_label(domain_name: &str) -> &'static str {
     }
 }
 
+/// The schema-qualified `eql_v3` domain a payload struct binds, e.g.
+/// `public.eql_v3_integer_eq`. The bindings describe v3 payloads only, so they
+/// name it literally, where the SQL surface writes the `{{prefix}}` placeholder.
+fn v3_domain_name(full: &str) -> String {
+    format!("public.{}{full}", eql_domains::PUBLIC_TYPNAME_PREFIX)
+}
+
 /// Render the catalog-derived struct doc lines for a domain: a summary line
 /// (`` `public.<name>` — <label>. ``) and a detail line listing the supported
 /// SQL operators and the required payload keys. Every part is derived from data
@@ -98,7 +105,7 @@ fn struct_doc_lines(full: &str, domain: &Domain) -> [String; 3] {
     // single leading space, so JSON Schema `description` is unaffected.
     let summary = format!(
         " `{}` — {}.",
-        crate::context::domain_name(full),
+        v3_domain_name(full),
         capability_label(domain.name)
     );
 
@@ -162,7 +169,7 @@ fn reference_docs(family: &DomainFamily) -> TokenStream {
 fn render_struct(family: &DomainFamily, domain: &Domain) -> TokenStream {
     let full = domain.full_name(family.name);
     let ident = format_ident!("{}", domain.struct_ident(family.name));
-    let sql_domain = crate::context::domain_name(&full);
+    let sql_domain = v3_domain_name(&full);
     let [doc_summary, doc_blank, doc_detail] = struct_doc_lines(&full, domain);
     let reference = reference_docs(family);
     let (encryption, version, context) = encryption_attrs(family, domain, false);
@@ -604,7 +611,7 @@ pub fn render_payload_rs() -> String {
         let module = format_ident!("{}", f.name);
         let strukt = format_ident!("{}", d.rust_struct_name(f.name));
         let full = d.full_name(f.name);
-        let doc = format!(" The `{}` payload.", crate::context::domain_name(&full));
+        let doc = format!(" The `{}` payload.", v3_domain_name(&full));
         variants.extend(quote! {
             #[doc = #doc]
             #strukt(super::#module::#strukt),
diff --git a/packages/eql/crates/eql-codegen/src/consts.rs b/packages/eql/crates/eql-codegen/src/consts.rs
index 3422195f5..dbbae25a1 100644
--- a/packages/eql/crates/eql-codegen/src/consts.rs
+++ b/packages/eql/crates/eql-codegen/src/consts.rs
@@ -14,7 +14,11 @@ pub(crate) const AUTO_GENERATED_MARKER: &str = "-- AUTOMATICALLY GENERATED FILE.
 pub(crate) const RUST_GENERATED_MARKER: &str =
     "// @generated by eql-codegen from the eql-domains catalog — do not edit";
 
-/// The public `eql_v3` API surface: query operators, index extractors,
+/// The generated SQL names its schemas and payload version by placeholder,
+/// never literally: [`crate::render`] writes the one source out as `eql_v3`
+/// (version 3) and `eql_v4` (version 4). See ADR-0002.
+///
+/// The public API schema (`eql_v3` once rendered): query operators, index extractors,
 /// aggregates, AND the operator-backing comparison **wrappers**
 /// (`eq`/`neq`/`lt`/`lte`/`gt`/`gte`/`contains`/`contained_by`). The wrappers
 /// are public because they are the function-form equivalent of every supported
@@ -22,7 +26,7 @@ pub(crate) const RUST_GENERATED_MARKER: &str =
 /// calls functions, not operators). User-column encrypted domains live in
 /// `public`; only index-term TYPES and never-invoked plumbing live in
 /// `INTERNAL_SCHEMA`.
-pub(crate) const SCHEMA: &str = "eql_v3";
+pub(crate) const SCHEMA: &str = "{{prefix}}";
 
 /// The schema housing INTERNAL eql_v3 objects only: the SEM index-term types
 /// (`hmac_256`, `bloom_filter`, `ore_block_256(_term)`, `ope_cllw`) and their
@@ -33,7 +37,16 @@ pub(crate) const SCHEMA: &str = "eql_v3";
 /// picker. NOTE: the operator-backing comparison *wrappers* are NOT here —
 /// they are public in `SCHEMA` (see above) so every operator has a callable
 /// function equivalent.
-pub(crate) const INTERNAL_SCHEMA: &str = "eql_v3_internal";
+pub(crate) const INTERNAL_SCHEMA: &str = "{{prefix}}_internal";
+
+/// The bare typname prefix of every public-schema encrypted domain, e.g. the
+/// `{{prefix}}_` of `public.{{prefix}}_integer_eq`. The SQL counterpart of
+/// [`eql_domains::PUBLIC_TYPNAME_PREFIX`], which stays the literal `eql_v3_`
+/// for the Rust bindings: those describe v3 payloads only.
+pub(crate) const PUBLIC_TYPNAME_PREFIX: &str = "{{prefix}}_";
+
+/// The payload version every domain CHECK compares `VALUE->>'v'` against.
+pub(crate) const EQL_VERSION: &str = "{{eql_version}}";
 
 /// Always-present payload keys checked for presence in every domain CHECK.
 /// Term-specific keys are appended after these by `context::domain_block`.
@@ -69,8 +82,8 @@ mod tests {
         // `list-schemas` subcommand) so a hand-edit to one side without the
         // other fails CI. Pinning the values here catches a Rust-side rename
         // before the SQL is even consulted.
-        assert_eq!(SCHEMA, "eql_v3");
-        assert_eq!(INTERNAL_SCHEMA, "eql_v3_internal");
+        assert_eq!(SCHEMA, "{{prefix}}");
+        assert_eq!(INTERNAL_SCHEMA, "{{prefix}}_internal");
         // `owned_schemas()` (lib.rs) is the public accessor the binary prints;
         // it must derive from these consts, public first.
         assert_eq!(crate::owned_schemas(), [SCHEMA, INTERNAL_SCHEMA]);
diff --git a/packages/eql/crates/eql-codegen/src/context.rs b/packages/eql/crates/eql-codegen/src/context.rs
index 066bdb189..cc94907a2 100644
--- a/packages/eql/crates/eql-codegen/src/context.rs
+++ b/packages/eql/crates/eql-codegen/src/context.rs
@@ -61,6 +61,7 @@ pub fn environment() -> minijinja::Environment<'static> {
     .expect("ore_fallback.sql template");
     env.add_global("schema", SCHEMA);
     env.add_global("internal_schema", INTERNAL_SCHEMA);
+    env.add_global("eql_version", EQL_VERSION);
     env
 }
 
@@ -390,15 +391,15 @@ pub struct OreFallbackEntry {
 }
 
 /// The bare pg_type typname of a public-schema encrypted domain: the catalog
-/// name carrying the [`eql_domains::PUBLIC_TYPNAME_PREFIX`] version prefix,
-/// e.g. `eql_v3_integer_eq`. The prefix keeps EQL domains from
+/// name carrying the [`PUBLIC_TYPNAME_PREFIX`] version prefix,
+/// e.g. `{{prefix}}_integer_eq` (`eql_v3_integer_eq` once rendered). The prefix keeps EQL domains from
 /// shadowing PostgreSQL built-in type names (`integer`, `text`, `json`, …)
 /// and gives each EQL version a distinct column-type namespace so multiple
 /// versions can coexist in one database. Catalog names stay bare — the prefix
 /// is applied only at SQL-name construction (file names, REQUIRE paths,
 /// struct idents, and test names all keep the bare name).
 pub fn public_typname(name: &str) -> String {
-    format!("{}{name}", eql_domains::PUBLIC_TYPNAME_PREFIX)
+    format!("{PUBLIC_TYPNAME_PREFIX}{name}")
 }
 
 /// The schema-qualified SQL domain type name, e.g. `public.eql_v3_integer_eq`.
@@ -463,13 +464,13 @@ mod tests {
 
     #[test]
     fn domain_name_qualifies_user_domains_with_public_schema() {
-        assert_eq!(domain_name("integer_eq"), "public.eql_v3_integer_eq");
+        assert_eq!(domain_name("integer_eq"), "public.{{prefix}}_integer_eq");
     }
 
     #[test]
     fn public_typname_carries_version_prefix() {
-        assert_eq!(public_typname("integer"), "eql_v3_integer");
-        assert_eq!(public_typname("text_match"), "eql_v3_text_match");
+        assert_eq!(public_typname("integer"), "{{prefix}}_integer");
+        assert_eq!(public_typname("text_match"), "{{prefix}}_text_match");
     }
 
     #[test]
diff --git a/packages/eql/crates/eql-codegen/src/generate.rs b/packages/eql/crates/eql-codegen/src/generate.rs
index 2e5ac00ae..d6c70836e 100644
--- a/packages/eql/crates/eql-codegen/src/generate.rs
+++ b/packages/eql/crates/eql-codegen/src/generate.rs
@@ -1150,6 +1150,65 @@ mod tests {
             .expect("domain name")
     }
 
+    // The renderers emit placeholder SQL. These shadow them, rendering their
+    // output as eql_v3, so the assertions below read as installed SQL and every
+    // rendered file is also checked to be free of literal names and unknown
+    // placeholders.
+    fn v3(sql: String) -> String {
+        crate::render::render_str(&sql, crate::render::EqlVersion::V3).expect("renders as eql_v3")
+    }
+
+    fn render_types_file(spec: &DomainFamily) -> String {
+        v3(super::render_types_file(spec))
+    }
+
+    fn render_functions_file(family_name: &str, domain: &Domain) -> String {
+        v3(super::render_functions_file(family_name, domain))
+    }
+
+    fn render_operators_file(family_name: &str, domain: &Domain) -> String {
+        v3(super::render_operators_file(family_name, domain))
+    }
+
+    fn render_aggregates_file(family_name: &str, domain: &Domain) -> Option<String> {
+        super::render_aggregates_file(family_name, domain).map(v3)
+    }
+
+    fn render_ore_fallback_file() -> String {
+        v3(super::render_ore_fallback_file())
+    }
+
+    fn render_json_entry_cross_functions(
+        spec: &DomainFamily,
+        domains: &[&Domain],
+        blocked_domains: &[&Domain],
+    ) -> String {
+        v3(super::render_json_entry_cross_functions(
+            spec,
+            domains,
+            blocked_domains,
+        ))
+    }
+
+    fn render_json_entry_cross_operators(
+        spec: &DomainFamily,
+        domains: &[&Domain],
+        blocked_domains: &[&Domain],
+    ) -> String {
+        v3(super::render_json_entry_cross_operators(
+            spec,
+            domains,
+            blocked_domains,
+        ))
+    }
+
+    fn render_type(spec: &DomainFamily, out_dir: &Path) -> Vec<(PathBuf, String)> {
+        super::render_type(spec, out_dir)
+            .into_iter()
+            .map(|(p, sql)| (p, v3(sql)))
+            .collect()
+    }
+
     use std::fs;
 
     #[test]
@@ -1873,8 +1932,8 @@ mod tests {
                 shape: Shape::Scalar,
             },
         );
-        assert_eq!(block.typname, "eql_v3_integer_q"); // no quote present → unchanged
-                                                       // keys are sql_str-escaped key tokens; none should carry a bare unescaped quote.
+        assert_eq!(block.typname, "{{prefix}}_integer_q"); // no quote present → unchanged
+                                                           // keys are sql_str-escaped key tokens; none should carry a bare unescaped quote.
         assert!(block.keys.iter().all(|k| !k.contains("o'")));
     }
 
@@ -2169,7 +2228,7 @@ mod tests {
     fn json_entry_type_is_derived_from_the_catalog() {
         // Not a hardcoded literal: a catalog rename or PUBLIC_TYPNAME_PREFIX bump
         // must flow through rather than silently drift (cf. #398 jsonb -> json).
-        assert_eq!(json_entry_type(), "public.eql_v3_json_entry");
+        assert_eq!(json_entry_type(), "public.{{prefix}}_json_entry");
         assert_eq!(json_entry_stem("integer"), "json_entry_integer");
         assert_eq!(
             json_entry_functions_path("integer"),
diff --git a/packages/eql/crates/eql-codegen/src/lib.rs b/packages/eql/crates/eql-codegen/src/lib.rs
index 03cdf3e48..49f5c9946 100644
--- a/packages/eql/crates/eql-codegen/src/lib.rs
+++ b/packages/eql/crates/eql-codegen/src/lib.rs
@@ -15,6 +15,7 @@ pub mod generate;
 pub mod go_eql;
 pub mod operator_surface;
 pub mod ordering;
+pub mod render;
 pub mod targets;
 pub mod writer;
 
diff --git a/packages/eql/crates/eql-codegen/src/main.rs b/packages/eql/crates/eql-codegen/src/main.rs
index 2dc95b195..c4d9f4bac 100644
--- a/packages/eql/crates/eql-codegen/src/main.rs
+++ b/packages/eql/crates/eql-codegen/src/main.rs
@@ -117,6 +117,33 @@ fn main() -> ExitCode {
         }
     }
 
+    // `render <3|4> <out-dir> <file>...`: write each placeholder source file
+    // (relative to the working directory) as that EQL version, to the same
+    // relative path under <out-dir>. Consumed by tasks/build.sh, which renders
+    // the ordered surface and assembles the installer from the result.
+    if args.len() >= 4 && args[1] == "render" {
+        let version = match args[2].parse::<eql_codegen::render::EqlVersion>() {
+            Ok(v) => v,
+            Err(e) => {
+                eprintln!("error: {e}");
+                return ExitCode::from(2);
+            }
+        };
+        let files: Vec<PathBuf> = args[4..].iter().map(PathBuf::from).collect();
+        return match eql_codegen::render::render_files(
+            std::path::Path::new("."),
+            &files,
+            std::path::Path::new(&args[3]),
+            version,
+        ) {
+            Ok(()) => ExitCode::SUCCESS,
+            Err(e) => {
+                eprintln!("error: {e}");
+                ExitCode::FAILURE
+            }
+        };
+    }
+
     // `clean`: remove the generated SQL surface (marker-aware) under every
     // src/v3/scalars/* type dir. Replaces build.sh's filename-pattern sweep;
     // hand-written files (no AUTO-GENERATED marker) are preserved.
@@ -152,6 +179,7 @@ fn main() -> ExitCode {
     eprintln!("Usage: eql-codegen            (generate all types)");
     eprintln!("       eql-codegen order      (print the src/v3 install order, one path per line)");
     eprintln!("       eql-codegen clean      (remove the generated SQL surface)");
+    eprintln!("       eql-codegen render <3|4> <out-dir> <file>... (render placeholder SQL as one EQL version)");
     eprintln!("       eql-codegen list-types (print catalog tokens)");
     eprintln!("       eql-codegen list-schemas (print owned schemas, public first)");
     eprintln!("       eql-codegen dump-catalog (print catalog surface as JSON)");
diff --git a/packages/eql/crates/eql-codegen/src/render.rs b/packages/eql/crates/eql-codegen/src/render.rs
new file mode 100644
index 000000000..ff5ce8ae6
--- /dev/null
+++ b/packages/eql/crates/eql-codegen/src/render.rs
@@ -0,0 +1,338 @@
+//! Renders the EQL SQL source as one EQL version.
+//!
+//! The SQL under `src/v3` names its schemas and its payload version by
+//! placeholder, never literally, so one source can be written out under two
+//! names (ADR-0002): `eql_v3` for cipherstash-client's terms and `eql_v4` for
+//! Stack Encrypt's. Postgres then refuses to compare a query term of one with a
+//! column of the other, at plan time.
+//!
+//! | placeholder       | `eql_v3` | `eql_v4` |
+//! |-------------------|----------|----------|
+//! | `{{prefix}}`      | `eql_v3` | `eql_v4` |
+//! | `{{eql_version}}` | `3`      | `4`      |
+//!
+//! `{{prefix}}` is both the schema (`{{prefix}}.eq_term`) and the start of every
+//! other name (`{{prefix}}_internal`, `public.{{prefix}}_text_eq`).
+//!
+//! Rendering is strict in both directions. An unknown or unterminated
+//! placeholder is an error, and so is a literal `eql_v3` or `eql_v4` in the
+//! source: a literal name would render the same in both outputs, so the `eql_v4`
+//! bundle would quietly reach into `eql_v3`.
+
+use std::fmt;
+use std::fs;
+use std::io;
+use std::path::{Component, Path, PathBuf};
+
+/// The schema-and-name prefix placeholder.
+pub const PREFIX: &str = "{{prefix}}";
+
+/// The payload-version placeholder.
+pub const EQL_VERSION: &str = "{{eql_version}}";
+
+/// An EQL version the source can be rendered as.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum EqlVersion {
+    /// `eql_v3`: payloads and terms written by cipherstash-client.
+    V3,
+    /// `eql_v4`: payloads and terms written by Stack Encrypt.
+    V4,
+}
+
+impl EqlVersion {
+    /// Every version, in release order.
+    pub const ALL: [EqlVersion; 2] = [EqlVersion::V3, EqlVersion::V4];
+
+    /// The payload version, as the domain CHECKs compare it: `"3"` or `"4"`.
+    pub fn number(self) -> &'static str {
+        match self {
+            EqlVersion::V3 => "3",
+            EqlVersion::V4 => "4",
+        }
+    }
+
+    /// The schema and name prefix: `eql_v3` or `eql_v4`.
+    pub fn prefix(self) -> &'static str {
+        match self {
+            EqlVersion::V3 => "eql_v3",
+            EqlVersion::V4 => "eql_v4",
+        }
+    }
+}
+
+impl std::str::FromStr for EqlVersion {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        EqlVersion::ALL
+            .into_iter()
+            .find(|v| v.number() == s)
+            .ok_or_else(|| format!("unknown EQL version {s:?} (expected 3 or 4)"))
+    }
+}
+
+/// Why a source could not be rendered. `line` is 1-based.
+#[derive(Debug, PartialEq, Eq)]
+pub enum RenderError {
+    /// `{{name}}` where `name` is not a placeholder this renderer knows.
+    UnknownPlaceholder { line: usize, name: String },
+    /// `{{` with no closing `}}` on the same line.
+    Unterminated { line: usize },
+    /// A literal `eql_v3` or `eql_v4` where a placeholder belongs.
+    LiteralName { line: usize, literal: &'static str },
+}
+
+impl fmt::Display for RenderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RenderError::UnknownPlaceholder { line, name } => write!(
+                f,
+                "line {line}: unknown placeholder {{{{{name}}}}} (expected {PREFIX} or {EQL_VERSION})"
+            ),
+            RenderError::Unterminated { line } => {
+                write!(f, "line {line}: `{{{{` with no closing `}}}}`")
+            }
+            RenderError::LiteralName { line, literal } => write!(
+                f,
+                "line {line}: literal `{literal}`; write {PREFIX} so the name follows the EQL version"
+            ),
+        }
+    }
+}
+
+impl std::error::Error for RenderError {}
+
+/// Render one source text as `version`.
+pub fn render_str(src: &str, version: EqlVersion) -> Result<String, RenderError> {
+    let mut out = String::with_capacity(src.len());
+    for (i, line) in src.split_inclusive('\n').enumerate() {
+        let lineno = i + 1;
+        for v in EqlVersion::ALL {
+            if line.contains(v.prefix()) {
+                return Err(RenderError::LiteralName {
+                    line: lineno,
+                    literal: v.prefix(),
+                });
+            }
+        }
+        let mut rest = line;
+        while let Some(open) = rest.find("{{") {
+            out.push_str(&rest[..open]);
+            let after = &rest[open + 2..];
+            let close = after
+                .find("}}")
+                .ok_or(RenderError::Unterminated { line: lineno })?;
+            match &after[..close] {
+                "prefix" => out.push_str(version.prefix()),
+                "eql_version" => out.push_str(version.number()),
+                other => {
+                    return Err(RenderError::UnknownPlaceholder {
+                        line: lineno,
+                        name: other.to_string(),
+                    })
+                }
+            }
+            rest = &after[close + 2..];
+        }
+        out.push_str(rest);
+    }
+    Ok(out)
+}
+
+/// Why a file could not be rendered.
+#[derive(Debug)]
+pub enum RenderFileError {
+    Io {
+        path: PathBuf,
+        source: io::Error,
+    },
+    Render {
+        path: PathBuf,
+        source: RenderError,
+    },
+    /// A file path that is absolute or climbs out with `..`. `out.join` would
+    /// put its output outside `out`, or over the source itself.
+    NotRelative {
+        path: PathBuf,
+    },
+}
+
+impl fmt::Display for RenderFileError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RenderFileError::Io { path, source } => write!(f, "{}: {source}", path.display()),
+            RenderFileError::Render { path, source } => {
+                write!(f, "{}: {source}", path.display())
+            }
+            RenderFileError::NotRelative { path } => write!(
+                f,
+                "{}: not a relative path inside the source root",
+                path.display()
+            ),
+        }
+    }
+}
+
+impl std::error::Error for RenderFileError {}
+
+/// Render each of `files` (relative to `root`) as `version`, writing it to the
+/// same relative path under `out`. Every file is rendered before any is
+/// written, so a source error leaves `out` as it was. A path that is absolute
+/// or contains `..` is refused, since its output would land outside `out`.
+pub fn render_files(
+    root: &Path,
+    files: &[PathBuf],
+    out: &Path,
+    version: EqlVersion,
+) -> Result<(), RenderFileError> {
+    let mut rendered = Vec::with_capacity(files.len());
+    for rel in files {
+        if !rel
+            .components()
+            .all(|c| matches!(c, Component::Normal(_) | Component::CurDir))
+        {
+            return Err(RenderFileError::NotRelative { path: rel.clone() });
+        }
+        let path = root.join(rel);
+        let src = fs::read_to_string(&path).map_err(|source| RenderFileError::Io {
+            path: path.clone(),
+            source,
+        })?;
+        let body = render_str(&src, version).map_err(|source| RenderFileError::Render {
+            path: path.clone(),
+            source,
+        })?;
+        rendered.push((out.join(rel), body));
+    }
+    for (dest, body) in rendered {
+        if let Some(parent) = dest.parent() {
+            fs::create_dir_all(parent).map_err(|source| RenderFileError::Io {
+                path: parent.to_path_buf(),
+                source,
+            })?;
+        }
+        fs::write(&dest, body).map_err(|source| RenderFileError::Io { path: dest, source })?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SRC: &str = "CREATE DOMAIN public.{{prefix}}_text_eq AS jsonb\n  \
+                       CHECK (VALUE->>'v' = '{{eql_version}}');\n\
+                       SELECT {{prefix}}_internal.f({{prefix}}.g());\n";
+
+    #[test]
+    fn renders_v3() {
+        assert_eq!(
+            render_str(SRC, EqlVersion::V3).unwrap(),
+            "CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n  \
+             CHECK (VALUE->>'v' = '3');\n\
+             SELECT eql_v3_internal.f(eql_v3.g());\n"
+        );
+    }
+
+    #[test]
+    fn renders_v4() {
+        assert_eq!(
+            render_str(SRC, EqlVersion::V4).unwrap(),
+            "CREATE DOMAIN public.eql_v4_text_eq AS jsonb\n  \
+             CHECK (VALUE->>'v' = '4');\n\
+             SELECT eql_v4_internal.f(eql_v4.g());\n"
+        );
+    }
+
+    #[test]
+    fn text_without_placeholders_is_unchanged() {
+        let src = "SELECT '{}'::jsonb, '{\"a\":1}', $$ { } $$;\n-- eql_v2 provenance\nno newline";
+        assert_eq!(render_str(src, EqlVersion::V4).unwrap(), src);
+    }
+
+    #[test]
+    fn rejects_literal_names() {
+        for (src, literal) in [
+            ("x\nSELECT eql_v3.f();\n", "eql_v3"),
+            ("x\n-- eql_v4_internal\n", "eql_v4"),
+        ] {
+            assert_eq!(
+                render_str(src, EqlVersion::V3),
+                Err(RenderError::LiteralName { line: 2, literal })
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_unknown_placeholder() {
+        assert_eq!(
+            render_str("{{prefix}}\n{{ prefix }}\n", EqlVersion::V3),
+            Err(RenderError::UnknownPlaceholder {
+                line: 2,
+                name: " prefix ".to_string()
+            })
+        );
+    }
+
+    #[test]
+    fn rejects_unterminated_placeholder() {
+        assert_eq!(
+            render_str("ok\n{{prefix\n}}\n", EqlVersion::V3),
+            Err(RenderError::Unterminated { line: 2 })
+        );
+    }
+
+    #[test]
+    fn parses_versions() {
+        assert_eq!("3".parse(), Ok(EqlVersion::V3));
+        assert_eq!("4".parse(), Ok(EqlVersion::V4));
+        assert!("2".parse::<EqlVersion>().is_err());
+    }
+
+    #[test]
+    fn render_files_writes_nothing_when_any_file_fails() {
+        let dir = std::env::temp_dir().join(format!("eql-render-{}", std::process::id()));
+        let root = dir.join("root");
+        let out = dir.join("out");
+        fs::create_dir_all(root.join("src/v3")).unwrap();
+        fs::write(root.join("src/v3/a.sql"), "SELECT {{prefix}}.f();\n").unwrap();
+        fs::write(root.join("src/v3/b.sql"), "SELECT eql_v3.f();\n").unwrap();
+
+        let files = [PathBuf::from("src/v3/a.sql"), PathBuf::from("src/v3/b.sql")];
+        let err = render_files(&root, &files, &out, EqlVersion::V4).unwrap_err();
+        assert!(err.to_string().contains("b.sql"), "{err}");
+        assert!(!out.exists());
+
+        render_files(&root, &files[..1], &out, EqlVersion::V4).unwrap();
+        assert_eq!(
+            fs::read_to_string(out.join("src/v3/a.sql")).unwrap(),
+            "SELECT eql_v4.f();\n"
+        );
+        fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn render_files_refuses_paths_outside_out() {
+        let dir = std::env::temp_dir().join(format!("eql-render-abs-{}", std::process::id()));
+        let root = dir.join("root");
+        let out = dir.join("out");
+        fs::create_dir_all(root.join("src")).unwrap();
+        let src = root.join("src/a.sql");
+        fs::write(&src, "SELECT {{prefix}}.f();\n").unwrap();
+
+        for rel in [src.clone(), PathBuf::from("src/../src/a.sql")] {
+            let err =
+                render_files(&root, std::slice::from_ref(&rel), &out, EqlVersion::V4).unwrap_err();
+            assert!(
+                matches!(&err, RenderFileError::NotRelative { path } if *path == rel),
+                "{err}"
+            );
+        }
+        assert_eq!(
+            fs::read_to_string(&src).unwrap(),
+            "SELECT {{prefix}}.f();\n"
+        );
+        assert!(!out.exists());
+        fs::remove_dir_all(&dir).unwrap();
+    }
+}
diff --git a/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2 b/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2
index ce27234cf..5c349bff7 100644
--- a/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2
+++ b/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2
@@ -8,7 +8,7 @@
 --!
 --! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,
 --! which ATTEMPTS to create the default btree operator class for
---! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege
+--! {{ internal_schema }}.ore_block_256 and skips it on insufficient_privilege
 --! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud
 --! Supabase and most hosted Postgres — run the installer as a non-superuser
 --! role). When the class was created, this file is a no-op.
diff --git a/packages/eql/crates/eql-codegen/templates/query_types.sql.j2 b/packages/eql/crates/eql-codegen/templates/query_types.sql.j2
index 2dee7bf01..eb93b0266 100644
--- a/packages/eql/crates/eql-codegen/templates/query_types.sql.j2
+++ b/packages/eql/crates/eql-codegen/templates/query_types.sql.j2
@@ -33,7 +33,7 @@ BEGIN
         AND jsonb_typeof(VALUE -> '{{ k }}') = 'array'
         AND jsonb_array_length(VALUE -> '{{ k }}') > 0
         {%- endfor %}
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{ eql_version }}'
       );
   END IF;
 
diff --git a/packages/eql/crates/eql-codegen/templates/types.sql.j2 b/packages/eql/crates/eql-codegen/templates/types.sql.j2
index cc854121c..82a0d5085 100644
--- a/packages/eql/crates/eql-codegen/templates/types.sql.j2
+++ b/packages/eql/crates/eql-codegen/templates/types.sql.j2
@@ -22,7 +22,7 @@ BEGIN
         AND jsonb_typeof(VALUE -> '{{ k }}') = 'array'
         AND jsonb_array_length(VALUE -> '{{ k }}') > 0
         {%- endfor %}
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{ eql_version }}'
       );
   END IF;
 
diff --git a/packages/eql/crates/eql-codegen/tests/cli.rs b/packages/eql/crates/eql-codegen/tests/cli.rs
index 4299ca989..2d3534fa9 100644
--- a/packages/eql/crates/eql-codegen/tests/cli.rs
+++ b/packages/eql/crates/eql-codegen/tests/cli.rs
@@ -81,7 +81,7 @@ fn list_schemas_subcommand_prints_owned_schemas() {
     );
     let stdout = String::from_utf8_lossy(&out.stdout);
     assert_eq!(
-        stdout, "eql_v3\neql_v3_internal\n",
+        stdout, "{{prefix}}\n{{prefix}}_internal\n",
         "list-schemas must print the public schema first, then the internal schema"
     );
 }
diff --git a/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md b/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md
index 79f7fad25..da7e425bf 100644
--- a/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md
+++ b/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md
@@ -756,14 +756,18 @@ lists, headers, or cleans it; it must declare its own `-- REQUIRE:` edges
 (usually to `<T>_types.sql` and whichever generated function or operator file it
 extends). Use it for cross-domain casts, helper functions, or type-specific
 constraints. Unlike the generated siblings, **`<T>_extensions.sql` IS
-committed.** (Neither `integer` nor `smallint` ships one today.)
+committed.** (Neither `integer` nor `smallint` ships one today.) Like every
+file under `src/v3`, it names schemas and the payload version by placeholder:
+`{{prefix}}.eq_term`, `public.{{prefix}}_integer_eq`,
+`VALUE->>'v' = '{{eql_version}}'`. The build rejects a literal `eql_v3`. See
+"Schema and version placeholders" in `AGENTS.md`.
 
 `tasks/pin_search_path_v3.sql` describes the fallback marker for inline-critical
 extension functions that take no domain argument and so escape the structural
 skip:
 
 ```sql
-COMMENT ON FUNCTION eql_v3.my_helper(...) IS 'eql-inline-critical: ...';
+COMMENT ON FUNCTION {{prefix}}.my_helper(...) IS 'eql-inline-critical: ...';
 ```
 
 The generator never emits this marker; every function it produces takes a domain
diff --git a/packages/eql/mise.toml b/packages/eql/mise.toml
index f4bbd55f6..4eb97643c 100644
--- a/packages/eql/mise.toml
+++ b/packages/eql/mise.toml
@@ -244,14 +244,14 @@ depends = ["build"]
 dir = "{{config_root}}"
 run = """
 bash tasks/test/symbol_order_selftest.sh
-bash tasks/test/verify_symbol_order_v3.sh src/deps-ordered-v3.txt
+bash tasks/test/verify_symbol_order_v3.sh build/render/eql_v3/deps-ordered.txt
 """
 
 [tasks."test:installer_complete"]
 description = "Assert the installer contains every ordered src/v3 file's body (DB-free)"
 depends = ["build"]
 dir = "{{config_root}}"
-run = "bash tasks/test/verify_installer_complete.sh src/deps-ordered-v3.txt release/cipherstash-encrypt.sql"
+run = "bash tasks/test/verify_installer_complete.sh build/render/eql_v3/deps-ordered.txt release/cipherstash-encrypt.sql build/render/eql_v3"
 
 [tasks."test:build_ordering_helpers"]
 description = "Unit tests for tasks/build/ordering.sh strip_require_lines (DB-free)"
diff --git a/packages/eql/src/v3/aggregates.sql b/packages/eql/src/v3/aggregates.sql
index 93402386f..c7f45c64c 100644
--- a/packages/eql/src/v3/aggregates.sql
+++ b/packages/eql/src/v3/aggregates.sql
@@ -3,7 +3,7 @@
 --! @file v3/aggregates.sql
 --! @brief Aggregates for grouping and deduplicating encrypted values.
 --!
---! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`
+--! Provides `{{prefix}}.grouped_value` — the aggregate you need to run a `GROUP BY`
 --! over an encrypted column and still get the encrypted value back.
 --!
 --! ## Grouping encrypted values
@@ -11,13 +11,13 @@
 --! Encryption in EQL is non-deterministic: encrypting the same value twice gives
 --! two different ciphertexts. So you cannot group rows by comparing the stored
 --! ciphertext. Instead you group by the column's *equality term*,
---! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal
+--! `{{prefix}}.eq_term(col)` — a deterministic keyed hash that is identical for equal
 --! plaintexts. Counting how many rows share each encrypted value looks like this
 --! (the term itself is opaque, so there is no reason to select it):
 --!
 --!   SELECT count(*)
 --!   FROM users
---!   GROUP BY eql_v3.eq_term(email);
+--!   GROUP BY {{prefix}}.eq_term(email);
 --!
 --! The equality term is opaque, though — you usually want the encrypted value
 --! itself back so your application can decrypt it. Adding the column to the
@@ -25,17 +25,17 @@
 --!
 --!   SELECT email, count(*)                        -- email is not in GROUP BY
 --!   FROM users
---!   GROUP BY eql_v3.eq_term(email);
+--!   GROUP BY {{prefix}}.eq_term(email);
 --!   -- ERROR: column "email" must appear in the GROUP BY clause or be used in
 --!   --        an aggregate function
 --!
 --! Every row in a group is an encryption of the same plaintext, so any one of
---! them represents the group. `eql_v3.grouped_value` is the aggregate that hands
+--! them represents the group. `{{prefix}}.grouped_value` is the aggregate that hands
 --! one back:
 --!
---!   SELECT eql_v3.grouped_value(email) AS email, count(*)
+--!   SELECT {{prefix}}.grouped_value(email) AS email, count(*)
 --!   FROM users
---!   GROUP BY eql_v3.eq_term(email);
+--!   GROUP BY {{prefix}}.eq_term(email);
 --!
 --! ## Deduplicating without an aggregate
 --!
@@ -43,11 +43,11 @@
 --! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality
 --! term, which lets you project the column directly:
 --!
---!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email
+--!   SELECT DISTINCT ON ({{prefix}}.eq_term(email)) email
 --!   FROM users
---!   ORDER BY eql_v3.eq_term(email);
+--!   ORDER BY {{prefix}}.eq_term(email);
 --!
---! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain
+--! Deduplicate on `{{prefix}}.eq_term(col)`, never on the column itself: a plain
 --! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the
 --! same value are NOT collapsed.
 --!
@@ -75,8 +75,8 @@
 --! @param value jsonb New value from the current row.
 --! @return jsonb The running state (first non-null value).
 --!
---! @see eql_v3.grouped_value
-CREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)
+--! @see {{prefix}}.grouped_value
+CREATE FUNCTION {{prefix}}_internal.grouped_value_sfunc(state jsonb, value jsonb)
 RETURNS jsonb
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
@@ -90,9 +90,9 @@ $$;
 --!
 --! Returns the first non-null value encountered within a `GROUP BY` group. Its
 --! primary use is projecting an encrypted column while grouping by that column's
---! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let
+--! equality term (`GROUP BY {{prefix}}.eq_term(col)`), where PostgreSQL will not let
 --! you `SELECT col` directly — see the file header for the worked example.
---! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and
+--! Accepts any {{prefix}} encrypted-domain value (each is a jsonb-backed domain) and
 --! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`
 --! with a combine function, so it works under partial/parallel aggregation on
 --! large `GROUP BY` workloads.
@@ -107,22 +107,22 @@ $$;
 --!   matches the eql_v2 original.
 --!
 --! Group encrypted rows by encrypted equality and project the encrypted
---! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;
+--! column. GROUP BY {{prefix}}.eq_term(...) groups by the HMAC equality term;
 --! grouped_value(...) returns a representative ciphertext for each group so
 --! PostgreSQL does not reject the bare column reference.
 --!
 --! @code{.sql}
---! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,
+--! SELECT {{prefix}}.grouped_value(encrypted_foo) AS encrypted_foo,
 --!        count(*)
 --! FROM some_table
---! GROUP BY eql_v3.eq_term(encrypted_foo);
+--! GROUP BY {{prefix}}.eq_term(encrypted_foo);
 --! @endcode
 --!
---! @see eql_v3_internal.grouped_value_sfunc
---! @see eql_v3.eq_term
-CREATE AGGREGATE eql_v3.grouped_value(jsonb) (
-  sfunc = eql_v3_internal.grouped_value_sfunc,
+--! @see {{prefix}}_internal.grouped_value_sfunc
+--! @see {{prefix}}.eq_term
+CREATE AGGREGATE {{prefix}}.grouped_value(jsonb) (
+  sfunc = {{prefix}}_internal.grouped_value_sfunc,
   stype = jsonb,
-  combinefunc = eql_v3_internal.grouped_value_sfunc,
+  combinefunc = {{prefix}}_internal.grouped_value_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/common.sql b/packages/eql/src/v3/common.sql
index a81ea3724..56c0edc33 100644
--- a/packages/eql/src/v3/common.sql
+++ b/packages/eql/src/v3/common.sql
@@ -1,9 +1,9 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/common.sql
---! @brief Common utility functions for the self-contained eql_v3 surface.
+--! @brief Common utility functions for the self-contained {{prefix}} surface.
 --!
---! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the
+--! Forked from src/common.sql (design D7) so the {{prefix}} ORE constructor owns the
 --! one transitive helper it needs without reaching into another schema. The
 --! eql_v2 original is unchanged.
 
@@ -29,7 +29,7 @@
 --!   raised) — both callers only ever pass an array or JSON null (`val->'ob'`),
 --!   so the divergence stays unreachable in practice; JSON null and empty
 --!   array still return NULL exactly as before.
-CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)
+CREATE FUNCTION {{prefix}}_internal.jsonb_array_to_bytea_array(val jsonb)
 RETURNS bytea[]
   IMMUTABLE
 AS $$
@@ -53,5 +53,5 @@ $$ LANGUAGE plpgsql;
 --! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the
 --! structural skip in tasks/pin_search_path_v3.sql does not recognise it;
 --! this marker is the documented manual opt-in.
-COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS
+COMMENT ON FUNCTION {{prefix}}_internal.jsonb_array_to_bytea_array(jsonb) IS
   'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';
diff --git a/packages/eql/src/v3/crypto.sql b/packages/eql/src/v3/crypto.sql
index bd99b1627..24e0662f2 100644
--- a/packages/eql/src/v3/crypto.sql
+++ b/packages/eql/src/v3/crypto.sql
@@ -1,11 +1,11 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/crypto.sql
---! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)
+--! @brief PostgreSQL pgcrypto extension enablement ({{prefix}} fork)
 --!
---! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency
+--! Forked from src/crypto.sql (design D8) so the entire {{prefix}} dependency
 --! closure lives under src/v3/. Enables the pgcrypto extension which provides
---! cryptographic functions used by the eql_v3 ORE comparison path.
+--! cryptographic functions used by the {{prefix}} ORE comparison path.
 --!
 --! Installs pgcrypto into the `extensions` schema (Supabase convention) to
 --! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto
diff --git a/packages/eql/src/v3/json/aggregates.sql b/packages/eql/src/v3/json/aggregates.sql
index 1d4d9ad86..50621e353 100644
--- a/packages/eql/src/v3/json/aggregates.sql
+++ b/packages/eql/src/v3/json/aggregates.sql
@@ -3,11 +3,11 @@
 -- REQUIRE: src/v3/sem/ope_cllw/types.sql
 
 --! @file v3/json/aggregates.sql
---! @brief min / max aggregates over public.eql_v3_json_entry.
+--! @brief min / max aggregates over public.{{prefix}}_json_entry.
 --!
 --! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by
 --! their CLLW OPE (`op`) term, so the extremum is picked by comparing
---! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the
+--! `{{prefix}}.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the
 --! generated scalar ord aggregates use. The ope_cllw bytea domain orders under
 --! native byte comparison, so `<` / `>` on the extracted terms needs no custom
 --! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar
@@ -18,9 +18,9 @@
 --! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would
 --! be inlinable and the planner could elide it.
 --!
---! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`
+--! @note **Only `op`-carrying entries are orderable.** `{{prefix}}.ord_term(entry)`
 --!   returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a
---!   `eql_v3.ord_term` btree NULL-filters from range scans. The state functions
+--!   `{{prefix}}.ord_term` btree NULL-filters from range scans. The state functions
 --!   therefore IGNORE `op`-less entries (they never become or survive as the
 --!   extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and
 --!   `op`-less entries and is not corrupted by an `op`-less seed. A naive
@@ -29,26 +29,26 @@
 --!   row is `op`-less. An all-`op`-less input has no orderable extremum and
 --!   returns the (arbitrary) STRICT seed.
 
---! @brief State function for min on public.eql_v3_json_entry.
+--! @brief State function for min on public.{{prefix}}_json_entry.
 --!
 --! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL
 --! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)
 --! entries are skipped explicitly (see the @note on this file).
 --!
---! @param state public.eql_v3_json_entry Running extremum.
---! @param value public.eql_v3_json_entry Candidate entry.
---! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.
-CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(
-  state public.eql_v3_json_entry,
-  value public.eql_v3_json_entry
+--! @param state public.{{prefix}}_json_entry Running extremum.
+--! @param value public.{{prefix}}_json_entry Candidate entry.
+--! @return public.{{prefix}}_json_entry The lesser orderable entry by `ord_term`.
+CREATE FUNCTION {{prefix}}_internal.jsonb_entry_min_sfunc(
+  state public.{{prefix}}_json_entry,
+  value public.{{prefix}}_json_entry
 )
-RETURNS public.eql_v3_json_entry
+RETURNS public.{{prefix}}_json_entry
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 DECLARE
-  value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);
-  state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);
+  value_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(value);
+  state_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(state);
 BEGIN
   -- A non-orderable (op-less) candidate never replaces the running extremum.
   IF value_ope IS NULL THEN
@@ -63,35 +63,35 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate over public.eql_v3_json_entry.
---! @param input public.eql_v3_json_entry
---! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.
-CREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (
-  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,
-  stype = public.eql_v3_json_entry,
-  combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,
+--! @brief min aggregate over public.{{prefix}}_json_entry.
+--! @param input public.{{prefix}}_json_entry
+--! @return public.{{prefix}}_json_entry The entry with the smallest CLLW OPE term.
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_json_entry) (
+  sfunc = {{prefix}}_internal.jsonb_entry_min_sfunc,
+  stype = public.{{prefix}}_json_entry,
+  combinefunc = {{prefix}}_internal.jsonb_entry_min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_json_entry.
+--! @brief State function for max on public.{{prefix}}_json_entry.
 --!
 --! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less
 --! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).
 --!
---! @param state public.eql_v3_json_entry Running extremum.
---! @param value public.eql_v3_json_entry Candidate entry.
---! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.
-CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(
-  state public.eql_v3_json_entry,
-  value public.eql_v3_json_entry
+--! @param state public.{{prefix}}_json_entry Running extremum.
+--! @param value public.{{prefix}}_json_entry Candidate entry.
+--! @return public.{{prefix}}_json_entry The greater orderable entry by `ord_term`.
+CREATE FUNCTION {{prefix}}_internal.jsonb_entry_max_sfunc(
+  state public.{{prefix}}_json_entry,
+  value public.{{prefix}}_json_entry
 )
-RETURNS public.eql_v3_json_entry
+RETURNS public.{{prefix}}_json_entry
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 DECLARE
-  value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);
-  state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);
+  value_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(value);
+  state_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(state);
 BEGIN
   -- A non-orderable (op-less) candidate never replaces the running extremum.
   IF value_ope IS NULL THEN
@@ -106,12 +106,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate over public.eql_v3_json_entry.
---! @param input public.eql_v3_json_entry
---! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.
-CREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (
-  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,
-  stype = public.eql_v3_json_entry,
-  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,
+--! @brief max aggregate over public.{{prefix}}_json_entry.
+--! @param input public.{{prefix}}_json_entry
+--! @return public.{{prefix}}_json_entry The entry with the largest CLLW OPE term.
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_json_entry) (
+  sfunc = {{prefix}}_internal.jsonb_entry_max_sfunc,
+  stype = public.{{prefix}}_json_entry,
+  combinefunc = {{prefix}}_internal.jsonb_entry_max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/json/blockers.sql b/packages/eql/src/v3/json/blockers.sql
index 935bc3105..cd9ee7b01 100644
--- a/packages/eql/src/v3/json/blockers.sql
+++ b/packages/eql/src/v3/json/blockers.sql
@@ -3,10 +3,10 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file v3/json/blockers.sql
---! @brief Native-jsonb firewall for public.eql_v3_json_search.
+--! @brief Native-jsonb firewall for public.{{prefix}}_json_search.
 --!
---! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons
---! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;
+--! public.{{prefix}}_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons
+--! Ordered comparisons < <= > >= are supported on public.{{prefix}}_json_entry;
 --! entry equality = <> is blocked because path entries carry no exact value
 --! selector. Root-document comparisons are also blocked.
 --! Every OTHER native jsonb operator reachable via domain fallback against the
@@ -16,7 +16,7 @@
 --!
 --! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let
 --! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the
---! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*
+--! exception) and delegates to the shared {{prefix}}.encrypted_domain_unsupported_*
 --! helpers. Each blocker's RETURNS type matches the native operator it shadows
 --! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a
 --! composed expression resolves and the body raises 'operator not supported',
@@ -25,417 +25,417 @@
 --! so the firewall fires.
 
 --! @brief Blocker: ? (key/element exists).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_exists(a public.{{prefix}}_json_search, b text)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '?');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal.jsonb_blocked_exists,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_exists,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text
 );
 
 --! @brief Blocker: ?| (any key exists).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text[] Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_exists_any(a public.{{prefix}}_json_search, b text[])
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '?|');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_exists_any,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text[]
 );
 
 --! @brief Blocker: ?& (all keys exist).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text[] Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_exists_all(a public.{{prefix}}_json_search, b text[])
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '?&');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_exists_all,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text[]
 );
 
 --! @brief Blocker: @? (jsonpath exists).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b jsonpath Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_jsonpath_exists(a public.{{prefix}}_json_search, b jsonpath)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@?');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_jsonpath_exists,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonpath
 );
 
 --! @brief Blocker: @@ (jsonpath predicate).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b jsonpath Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_jsonpath_match(a public.{{prefix}}_json_search, b jsonpath)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@@');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_jsonpath_match,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonpath
 );
 
 --! @brief Blocker: #> (path extract, native returns jsonb).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text[] Native RHS operand.
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_path_extract(a public.{{prefix}}_json_search, b text[])
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '#>');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_path_extract,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text[]
 );
 
 --! @brief Blocker: #>> (path extract as text).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text[] Native RHS operand.
 --! @return text Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_path_extract_text(a public.{{prefix}}_json_search, b text[])
 RETURNS text
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_text('public.{{prefix}}_json_search', '#>>');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_path_extract_text,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text[]
 );
 
 --! @brief Blocker: - (delete key, text RHS; native returns jsonb).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text Native RHS operand.
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_text(a public.{{prefix}}_json_search, b text)
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '-');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_text,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text
 );
 
 --! @brief Blocker: - (delete index, integer RHS).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b integer Native RHS operand.
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_int(a public.{{prefix}}_json_search, b integer)
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '-');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_int,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = integer
 );
 
 --! @brief Blocker: - (delete keys, text[] RHS).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text[] Native RHS operand.
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_array(a public.{{prefix}}_json_search, b text[])
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '-');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_array,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text[]
 );
 
 --! @brief Blocker: #- (delete at path).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b text[] Native RHS operand.
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_path(a public.{{prefix}}_json_search, b text[])
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '#-');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_path,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = text[]
 );
 
 --! @brief Blocker: || (concatenate, encrypted on the left).
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b jsonb Native RHS operand.
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_concat(a public.{{prefix}}_json_search, b jsonb)
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '||');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal.jsonb_blocked_concat,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_concat,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 --! @brief Blocker: || (concatenate, encrypted on the right).
 --! @param a jsonb Native LHS operand.
---! @param b public.eql_v3_json_search Right operand (encrypted payload).
+--! @param b public.{{prefix}}_json_search Right operand (encrypted payload).
 --! @return jsonb Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_concat_rhs(a jsonb, b public.{{prefix}}_json_search)
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '||');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_concat_rhs,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 ------------------------------------------------------------------------------
 -- Root-document comparison blockers.
 ------------------------------------------------------------------------------
 
---! @brief Blocker: root public.eql_v3_json_search document comparisons.
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
---! @param b public.eql_v3_json_search Right operand (encrypted payload).
+--! @brief Blocker: root public.{{prefix}}_json_search document comparisons.
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
+--! @param b public.{{prefix}}_json_search Right operand (encrypted payload).
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_compare_json_json(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', 'comparison');
 END;
 $$ LANGUAGE plpgsql;
 
---! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @brief Blocker: root public.{{prefix}}_json_search-to-jsonb comparisons.
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b jsonb Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_compare_json_jsonb(a public.{{prefix}}_json_search, b jsonb)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', 'comparison');
 END;
 $$ LANGUAGE plpgsql;
 
---! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.
+--! @brief Blocker: root jsonb-to-public.{{prefix}}_json_search comparisons.
 --! @param a jsonb Native LHS operand.
---! @param b public.eql_v3_json_search Right operand (encrypted payload).
+--! @param b public.{{prefix}}_json_search Right operand (encrypted payload).
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.{{prefix}}_json_search)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', 'comparison');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 ------------------------------------------------------------------------------
@@ -443,46 +443,46 @@ CREATE OPERATOR >= (
 ------------------------------------------------------------------------------
 
 --! @brief Block document containment against an extracted path entry.
---! @param a public.eql_v3_json_search Encrypted document.
---! @param b public.eql_v3_json_entry Extracted path entry.
+--! @param a public.{{prefix}}_json_search Encrypted document.
+--! @param b public.{{prefix}}_json_entry Extracted path entry.
 --! @return boolean Never returns; always raises 'operator not supported'.
 --! @note An extracted path entry carries no value selector, so this signature
 --!       cannot express exact equality. It is explicitly claimed to prevent
 --!       PostgreSQL flattening both domains to native jsonb containment.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contains_entry(a public.{{prefix}}_json_search, b public.{{prefix}}_json_entry)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@>');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,
-  LEFTARG = public.eql_v3_json_search,
-  RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_contains_entry,
+  LEFTARG = public.{{prefix}}_json_search,
+  RIGHTARG = public.{{prefix}}_json_entry
 );
 
 --! @brief Block reverse containment from an extracted path entry.
---! @param a public.eql_v3_json_entry Extracted path entry.
---! @param b public.eql_v3_json_search Encrypted document.
+--! @param a public.{{prefix}}_json_entry Extracted path entry.
+--! @param b public.{{prefix}}_json_search Encrypted document.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_entry_contained(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_search)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_entry', '<@');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,
-  LEFTARG = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_search
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_entry_contained,
+  LEFTARG = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 ------------------------------------------------------------------------------
@@ -490,81 +490,81 @@ CREATE OPERATOR <@ (
 ------------------------------------------------------------------------------
 
 --! @brief Blocker: @> with encrypted root document and native jsonb.
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b jsonb Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contains_json_jsonb(a public.{{prefix}}_json_search, b jsonb)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@>');
 END;
 $$ LANGUAGE plpgsql;
 
 --! @brief Blocker: @> with native jsonb and encrypted root document.
 --! @param a jsonb Native LHS operand.
---! @param b public.eql_v3_json_search Right operand (encrypted payload).
+--! @param b public.{{prefix}}_json_search Right operand (encrypted payload).
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.{{prefix}}_json_search)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@>');
 END;
 $$ LANGUAGE plpgsql;
 
 --! @brief Blocker: <@ with encrypted root document and native jsonb.
---! @param a public.eql_v3_json_search Left operand (encrypted payload).
+--! @param a public.{{prefix}}_json_search Left operand (encrypted payload).
 --! @param b jsonb Native RHS operand.
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contained_json_jsonb(a public.{{prefix}}_json_search, b jsonb)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '<@');
 END;
 $$ LANGUAGE plpgsql;
 
 --! @brief Blocker: <@ with native jsonb and encrypted root document.
 --! @param a jsonb Native LHS operand.
---! @param b public.eql_v3_json_search Right operand (encrypted payload).
+--! @param b public.{{prefix}}_json_search Right operand (encrypted payload).
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.{{prefix}}_json_search)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '<@');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_contains_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_contains_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,
-  LEFTARG = public.eql_v3_json_search,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_contained_json_jsonb,
+  LEFTARG = public.{{prefix}}_json_search,
   RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,
+  FUNCTION = {{prefix}}_internal.jsonb_blocked_contained_jsonb_json,
   LEFTARG = jsonb,
-  RIGHTARG = public.eql_v3_json_search
+  RIGHTARG = public.{{prefix}}_json_search
 );
diff --git a/packages/eql/src/v3/json/functions.sql b/packages/eql/src/v3/json/functions.sql
index fa8acdc2f..d8ba0e59c 100644
--- a/packages/eql/src/v3/json/functions.sql
+++ b/packages/eql/src/v3/json/functions.sql
@@ -5,14 +5,14 @@
 
 --! @file v3/json/functions.sql
 --! @brief Extractors, containment engine, and path/array functions for the
---!        eql_v3 encrypted-JSONB (SteVec) surface.
+--!        {{prefix}} encrypted-JSONB (SteVec) surface.
 --!
 --! `selector` parameters here are *encrypted-side* selector hashes — the
 --! deterministic hash the crypto layer emits in the `s` field of each sv
 --! element. Plaintext JSONPaths are never accepted at runtime.
 
 ------------------------------------------------------------------------------
--- Envelope helpers (eql_v3 owns these; jsonb-only)
+-- Envelope helpers ({{prefix}} owns these; jsonb-only)
 ------------------------------------------------------------------------------
 
 --! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.
@@ -20,7 +20,7 @@
 --! `h` is the document's key header — hoisted once to the envelope because
 --! every sv entry encrypts under the document's single data key. Grafting it
 --! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)
---! is what keeps an extracted `public.eql_v3_json_entry` self-contained
+--! is what keeps an extracted `public.{{prefix}}_json_entry` self-contained
 --! decryptable: decryption needs the header plus the entry's own `s` (the
 --! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the
 --! keys entirely on payloads that lack them (e.g. a raw scalar envelope has
@@ -28,7 +28,7 @@
 --!
 --! @param val jsonb encrypted EQL payload
 --! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.
-CREATE FUNCTION eql_v3.meta_data(val jsonb)
+CREATE FUNCTION {{prefix}}.meta_data(val jsonb)
   RETURNS jsonb
   IMMUTABLE STRICT PARALLEL SAFE
   LANGUAGE SQL
@@ -38,7 +38,7 @@ AS $$
   );
 $$;
 
-COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS
+COMMENT ON FUNCTION {{prefix}}.meta_data(jsonb) IS
   'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';
 
 --! @brief Extract ciphertext (c) from a raw jsonb encrypted value.
@@ -48,9 +48,9 @@ COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS
 --! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT
 --!       decryptable on its own: the decryption unit is the entry — its `s`
 --!       (nonce source), `c`, and the document key header `h` (grafted onto
---!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'
+--!       extracted entries by `->`; see {{prefix}}.meta_data). Scalar payloads'
 --!       `c` remains a self-describing encrypted record.
-CREATE FUNCTION eql_v3.ciphertext(val jsonb)
+CREATE FUNCTION {{prefix}}.ciphertext(val jsonb)
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -71,7 +71,7 @@ $$ LANGUAGE plpgsql;
 --! @param val jsonb encrypted EQL payload
 --! @return text The selector value.
 --! @throws Exception if `s` is absent.
-CREATE FUNCTION eql_v3.selector(val jsonb)
+CREATE FUNCTION {{prefix}}.selector(val jsonb)
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -86,9 +86,9 @@ $$ LANGUAGE plpgsql;
 
 --! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK
 --!        guarantees `s` is present, so this is a simple field access.
---! @param entry public.eql_v3_json_entry
+--! @param entry public.{{prefix}}_json_entry
 --! @return text The selector value.
-CREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.selector(entry public.{{prefix}}_json_entry)
   RETURNS text
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -116,30 +116,30 @@ $$;
 --! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —
 --! entries no longer carry it.
 --!
---! @param entry public.eql_v3_json_entry
+--! @param entry public.{{prefix}}_json_entry
 --! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).
-CREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.ope_term(entry public.{{prefix}}_json_entry)
   RETURNS bytea
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT decode(entry ->> 'op', 'hex')
 $$;
 
---! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).
---! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or
---!             eql_v3.ord_term for ordered comparisons. This term is not an
+--! @brief Deprecated compatibility alias for {{prefix}}.ope_term(json_entry).
+--! @deprecated Use {{prefix}}.ope_term for raw OPE-equivalence inspection, or
+--!             {{prefix}}.ord_term for ordered comparisons. This term is not an
 --!             exact equality representation.
---! @param entry public.eql_v3_json_entry
+--! @param entry public.{{prefix}}_json_entry
 --! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).
-CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.eq_term(entry public.{{prefix}}_json_entry)
   RETURNS bytea
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.ope_term(entry)
+  SELECT {{prefix}}.ope_term(entry)
 $$;
 
-COMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS
-  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';
+COMMENT ON FUNCTION {{prefix}}.eq_term(public.{{prefix}}_json_entry) IS
+  'DEPRECATED: use {{prefix}}.ope_term(json_entry); OPE bytes are not exact equality terms';
 
 ------------------------------------------------------------------------------
 -- CLLW OPE per-entry overload (converged with the scalar ord_term)
@@ -148,24 +148,24 @@ COMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS
 --! @brief Extract the CLLW OPE index term from a ste_vec entry.
 --!
 --! An sv-element `op` term is only ever present on an sv element, never at a
---! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —
---! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`
+--! root encrypted value, so the typed overload accepts public.{{prefix}}_json_entry —
+--! the jsonb_entry twin of the generated scalar `{{prefix}}.ord_term`
 --! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /
 --! `decode` chain propagates it), so btree NULL-filters such rows from range
---! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders
+--! queries. The returned {{prefix}}_internal.ope_cllw is a bytea domain: it orders
 --! under native byte comparison with the DEFAULT btree opclass, so a
---! functional index on `eql_v3.ord_term(col -> 'selector')` engages
+--! functional index on `{{prefix}}.ord_term(col -> 'selector')` engages
 --! structurally with no custom operator class (Supabase/managed-Postgres
 --! safe).
 --!
---! @param entry public.eql_v3_json_entry
---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when
+--! @param entry public.{{prefix}}_json_entry
+--! @return {{prefix}}_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when
 --!         `op` is absent.
-CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)
-  RETURNS eql_v3_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(entry public.{{prefix}}_json_entry)
+  RETURNS {{prefix}}_internal.ope_cllw
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.ope_cllw(entry::jsonb)
+  SELECT {{prefix}}_internal.ope_cllw(entry::jsonb)
 $$;
 
 ------------------------------------------------------------------------------
@@ -179,7 +179,7 @@ $$;
 --!
 --! @param val jsonb encrypted EQL payload
 --! @return jsonb[] Array of sv elements.
-CREATE FUNCTION eql_v3.ste_vec(val jsonb)
+CREATE FUNCTION {{prefix}}.ste_vec(val jsonb)
   RETURNS jsonb[]
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -205,7 +205,7 @@ $$ LANGUAGE plpgsql;
 --! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).
 --! @param val jsonb encrypted EQL payload
 --! @return boolean True if `a` is present and true.
-CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)
+CREATE FUNCTION {{prefix}}_internal.is_ste_vec_array(val jsonb)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -231,7 +231,7 @@ $$ LANGUAGE plpgsql;
 --!
 --! @param val jsonb encrypted EQL payload
 --! @return jsonb[] Array of objects with only deterministic fields.
-CREATE FUNCTION eql_v3.jsonb_array(val jsonb)
+CREATE FUNCTION {{prefix}}.jsonb_array(val jsonb)
 RETURNS jsonb[]
 IMMUTABLE STRICT PARALLEL SAFE
 LANGUAGE SQL
@@ -247,7 +247,7 @@ AS $$
   );
 $$;
 
-COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS
+COMMENT ON FUNCTION {{prefix}}.jsonb_array(jsonb) IS
   'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';
 
 ------------------------------------------------------------------------------
@@ -261,19 +261,19 @@ COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS
 --! @note Public raw-`jsonb[]` containment helper over the extracted
 --!       deterministic fields — the function-form entrypoint for containment on
 --!       platforms without operator support (Supabase/PostgREST). The typed
---!       `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to
---!       `eql_v3.jsonb_document_contains` instead — but both agree on the result (a
+--!       `public.{{prefix}}_json_search` `@>` operator does NOT call this function — it binds to
+--!       `{{prefix}}.jsonb_document_contains` instead — but both agree on the result (a
 --!       parity test pins this). Also the documented GIN index expression
---!       (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.
-CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)
+--!       (`{{prefix}}.jsonb_array(col)`); see docs/reference/database-indexes.md.
+CREATE FUNCTION {{prefix}}.jsonb_contains(a jsonb, b jsonb)
 RETURNS boolean
 IMMUTABLE STRICT PARALLEL SAFE
 LANGUAGE SQL
 AS $$
-  SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);
+  SELECT {{prefix}}.jsonb_array(a) @> {{prefix}}.jsonb_array(b);
 $$;
 
-COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS
+COMMENT ON FUNCTION {{prefix}}.jsonb_contains(jsonb, jsonb) IS
   'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';
 
 --! @brief GIN-indexable "is contained by" check.
@@ -282,17 +282,17 @@ COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS
 --! @return boolean True if all elements of a are contained in b.
 --! @note Public raw-`jsonb[]` reverse-containment helper — the function-form
 --!       entrypoint for `<@` on platforms without operator support. The typed
---!       `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,
+--!       `public.{{prefix}}_json_search` `<@` operator binds to `{{prefix}}.jsonb_document_contains` instead,
 --!       but both agree on the result.
-CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)
+CREATE FUNCTION {{prefix}}.jsonb_contained_by(a jsonb, b jsonb)
 RETURNS boolean
 IMMUTABLE STRICT PARALLEL SAFE
 LANGUAGE SQL
 AS $$
-  SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);
+  SELECT {{prefix}}.jsonb_array(a) <@ {{prefix}}.jsonb_array(b);
 $$;
 
-COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS
+COMMENT ON FUNCTION {{prefix}}.jsonb_contained_by(jsonb, jsonb) IS
   'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';
 
 --! @brief Check if an sv array contains a specific sv element.
@@ -311,7 +311,7 @@ COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS
 --! @param a jsonb[] sv array to search within.
 --! @param b jsonb sv element to search for.
 --! @return boolean True if b's selector is present in any element of a.
-CREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)
+CREATE FUNCTION {{prefix}}.jsonb_document_contains(a jsonb[], b jsonb)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -324,7 +324,7 @@ AS $$
 
     FOR idx IN 1..array_length(a, 1) LOOP
       _a := a[idx];
-      result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));
+      result := result OR ({{prefix}}.selector(_a) = {{prefix}}.selector(b));
       EXIT WHEN result;
     END LOOP;
 
@@ -337,48 +337,48 @@ $$ LANGUAGE plpgsql;
 --! Empty b is always contained. Each element of b must have its selector
 --! present in some element of a (selector-subset containment).
 --!
---! @param a public.eql_v3_json_search Container.
---! @param b public.eql_v3_json_search Elements to find.
+--! @param a public.{{prefix}}_json_search Container.
+--! @param b public.{{prefix}}_json_search Elements to find.
 --! @return boolean True if all elements of b are contained in a.
---! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)
-CREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)
+--! @see {{prefix}}.jsonb_document_contains(jsonb[], jsonb)
+CREATE FUNCTION {{prefix}}.jsonb_document_contains(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.to_ste_vec_query(a)::jsonb
-       @> eql_v3.to_ste_vec_query(b)::jsonb
+  SELECT {{prefix}}.to_ste_vec_query(a)::jsonb
+       @> {{prefix}}.to_ste_vec_query(b)::jsonb
 $$;
 
 --! @cond deprecated_compatibility
 --! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).
---! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).
+--! @deprecated Use {{prefix}}.jsonb_document_contains(jsonb[], jsonb).
 --! @param a jsonb[] sv array to search within.
 --! @param b jsonb sv element to search for.
 --! @return boolean True if b's selector is present in any element of a.
-CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)
+CREATE FUNCTION {{prefix}}.ste_vec_contains(a jsonb[], b jsonb)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.jsonb_document_contains(a, b)
+  SELECT {{prefix}}.jsonb_document_contains(a, b)
 $$;
 
-COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS
-  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';
+COMMENT ON FUNCTION {{prefix}}.ste_vec_contains(jsonb[], jsonb) IS
+  'DEPRECATED: use {{prefix}}.jsonb_document_contains(jsonb[], jsonb)';
 
 --! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).
---! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).
---! @param a public.eql_v3_json_search Container.
---! @param b public.eql_v3_json_search Elements to find.
+--! @deprecated Use {{prefix}}.jsonb_document_contains(public.{{prefix}}_json_search, public.{{prefix}}_json_search).
+--! @param a public.{{prefix}}_json_search Container.
+--! @param b public.{{prefix}}_json_search Elements to find.
 --! @return boolean True if all elements of b are contained in a.
-CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}.ste_vec_contains(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.jsonb_document_contains(a, b)
+  SELECT {{prefix}}.jsonb_document_contains(a, b)
 $$;
 
-COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS
-  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';
+COMMENT ON FUNCTION {{prefix}}.ste_vec_contains(public.{{prefix}}_json_search, public.{{prefix}}_json_search) IS
+  'DEPRECATED: use {{prefix}}.jsonb_document_contains(json_search, json_search)';
 --! @endcond
 
 ------------------------------------------------------------------------------
@@ -389,30 +389,30 @@ COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eq
 --!
 --! Returns one jsonb_entry row per matching encrypted element. Returns empty
 --! set on no match. It deliberately does not wrap multiple matches as an
---! public.eql_v3_json_search document, because the root document domain requires an `sv`
---! array and single leaves belong to public.eql_v3_json_entry.
+--! public.{{prefix}}_json_search document, because the root document domain requires an `sv`
+--! array and single leaves belong to public.{{prefix}}_json_entry.
 --!
 --! @param val jsonb encrypted EQL payload with `sv`.
 --! @param selector text Selector hash (`s` value).
---! @return SETOF public.eql_v3_json_entry Matching encrypted entries.
---! @see eql_v3.jsonb_path_query_first
-CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)
-  RETURNS SETOF public.eql_v3_json_entry
+--! @return SETOF public.{{prefix}}_json_entry Matching encrypted entries.
+--! @see {{prefix}}.jsonb_path_query_first
+CREATE FUNCTION {{prefix}}.jsonb_path_query(val jsonb, selector text)
+  RETURNS SETOF public.{{prefix}}_json_entry
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry
+  SELECT ({{prefix}}.meta_data(val) || elem)::public.{{prefix}}_json_entry
   FROM jsonb_array_elements(val -> 'sv') elem
   WHERE elem ->> 's' = selector
 $$;
 
-COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS
+COMMENT ON FUNCTION {{prefix}}.jsonb_path_query(jsonb, text) IS
   'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';
 
 --! @brief Check if a selector path exists in encrypted JSONB.
 --! @param val jsonb encrypted EQL payload.
 --! @param selector text Selector hash to test.
 --! @return boolean True if a matching element exists.
-CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)
+CREATE FUNCTION {{prefix}}.jsonb_path_exists(val jsonb, selector text)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -422,24 +422,24 @@ AS $$
   );
 $$;
 
-COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS
+COMMENT ON FUNCTION {{prefix}}.jsonb_path_exists(jsonb, text) IS
   'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';
 
 --! @brief Get the first sv element matching `selector`, or NULL.
 --! @param val jsonb encrypted EQL payload.
 --! @param selector text Selector hash to match.
---! @return public.eql_v3_json_entry First matching element or NULL.
-CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)
-  RETURNS public.eql_v3_json_entry
+--! @return public.{{prefix}}_json_entry First matching element or NULL.
+CREATE FUNCTION {{prefix}}.jsonb_path_query_first(val jsonb, selector text)
+  RETURNS public.{{prefix}}_json_entry
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry
+  SELECT ({{prefix}}.meta_data(val) || elem)::public.{{prefix}}_json_entry
   FROM jsonb_array_elements(val -> 'sv') elem
   WHERE elem ->> 's' = selector
   LIMIT 1
 $$;
 
-COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS
+COMMENT ON FUNCTION {{prefix}}.jsonb_path_query_first(jsonb, text) IS
   'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';
 
 ------------------------------------------------------------------------------
@@ -450,7 +450,7 @@ COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS
 --! @param val jsonb encrypted EQL payload (must have `a` flag true).
 --! @return integer Number of elements.
 --! @throws Exception 'cannot get array length of a non-array' if not an array.
-CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)
+CREATE FUNCTION {{prefix}}.jsonb_array_length(val jsonb)
   RETURNS integer
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -458,8 +458,8 @@ AS $$
   DECLARE
     sv jsonb[];
   BEGIN
-    IF eql_v3_internal.is_ste_vec_array(val) THEN
-      sv := eql_v3.ste_vec(val);
+    IF {{prefix}}_internal.is_ste_vec_array(val) THEN
+      sv := {{prefix}}.ste_vec(val);
       RETURN array_length(sv, 1);
     END IF;
 
@@ -469,10 +469,10 @@ $$ LANGUAGE plpgsql;
 
 --! @brief Extract elements of an encrypted JSONB array as rows.
 --! @param val jsonb encrypted EQL payload (must have `a` flag true).
---! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).
+--! @return SETOF public.{{prefix}}_json_entry One row per element (metadata preserved).
 --! @throws Exception 'cannot extract elements from non-array' if not an array.
-CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)
-  RETURNS SETOF public.eql_v3_json_entry
+CREATE FUNCTION {{prefix}}.jsonb_array_elements(val jsonb)
+  RETURNS SETOF public.{{prefix}}_json_entry
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
 AS $$
@@ -481,25 +481,25 @@ AS $$
     meta jsonb;
     item jsonb;
   BEGIN
-    IF NOT eql_v3_internal.is_ste_vec_array(val) THEN
+    IF NOT {{prefix}}_internal.is_ste_vec_array(val) THEN
       RAISE 'cannot extract elements from non-array';
     END IF;
 
-    meta := eql_v3.meta_data(val);
-    sv := eql_v3.ste_vec(val);
+    meta := {{prefix}}.meta_data(val);
+    sv := {{prefix}}.ste_vec(val);
 
     FOR idx IN 1..array_length(sv, 1) LOOP
       item = sv[idx];
-      RETURN NEXT (meta || item)::public.eql_v3_json_entry;
+      RETURN NEXT (meta || item)::public.{{prefix}}_json_entry;
     END LOOP;
 
     RETURN;
   END;
 $$ LANGUAGE plpgsql;
 
--- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext
+-- NOTE: `{{prefix}}.jsonb_array_elements_text` (SETOF bare per-element ciphertext
 -- text) was removed with the envelope wire format: an sv entry's `c` is raw
 -- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext
 -- stream is not decryptable and the function had no remaining correct use.
--- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the
+-- Use `{{prefix}}.jsonb_array_elements` — its entry rows carry `s`, `c`, and the
 -- grafted document key header `h`, the complete decryption unit.
diff --git a/packages/eql/src/v3/json/operators.sql b/packages/eql/src/v3/json/operators.sql
index eddf1e753..e520f47f3 100644
--- a/packages/eql/src/v3/json/operators.sql
+++ b/packages/eql/src/v3/json/operators.sql
@@ -5,7 +5,7 @@
 -- REQUIRE: src/v3/sem/ope_cllw/types.sql
 
 --! @file v3/json/operators.sql
---! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.
+--! @brief Operators on public.{{prefix}}_json_search and public.{{prefix}}_json_entry.
 
 ------------------------------------------------------------------------------
 -- -> field accessor (returns jsonb_entry)
@@ -15,67 +15,67 @@
 --!
 --! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged
 --! in. Inlinable: range predicates reduce structurally through
---! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that
+--! `{{prefix}}.ord_term(col -> 'sel')` and match a functional btree index on that
 --! expression. Exact equality is document containment on a value selector.
 --!
 --! @warning The selector operand MUST carry a known type — a text-typed
 --!   parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).
 --!   A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`
 --!   operator and silently returns native jsonb semantics (a root-key lookup,
---!   typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`
+--!   typically NULL), NOT this operator: PostgreSQL reduces the `public.{{prefix}}_json_search`
 --!   domain to its base type `jsonb` when resolving an unknown-typed RHS, and the
 --!   native base-type operator wins the exact-match tiebreak. This is intrinsic to
 --!   the domain type-kind and applies to the native-jsonb blockers too. See
 --!   the "Typed operands" caveat in docs/reference/json-support.md.
 --!
---! @param e public.eql_v3_json_search Root encrypted payload.
+--! @param e public.{{prefix}}_json_search Root encrypted payload.
 --! @param selector text Selector hash.
---! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.
-CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector text)
-  RETURNS public.eql_v3_json_entry
+--! @return public.{{prefix}}_json_entry Matching entry merged with root meta, or NULL.
+CREATE FUNCTION {{prefix}}."->"(e public.{{prefix}}_json_search, selector text)
+  RETURNS public.{{prefix}}_json_entry
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT (
-    eql_v3.meta_data(e) ||
+    {{prefix}}.meta_data(e) ||
     jsonb_path_query_first(
       e,
       '$.sv[*] ? (@.s == $sel)'::jsonpath,
       jsonb_build_object('sel', selector)
     )
-  )::public.eql_v3_json_entry
+  )::public.{{prefix}}_json_entry
 $$;
 
 CREATE OPERATOR ->(
-  FUNCTION=eql_v3."->",
-  LEFTARG=public.eql_v3_json_search,
+  FUNCTION={{prefix}}."->",
+  LEFTARG=public.{{prefix}}_json_search,
   RIGHTARG=text
 );
 
 --! @brief -> operator with integer array index (0-based, JSONB convention).
---! @param e public.eql_v3_json_search Encrypted sv-array payload.
+--! @param e public.{{prefix}}_json_search Encrypted sv-array payload.
 --! @param selector integer Array index.
---! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.
-CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector integer)
-  RETURNS public.eql_v3_json_entry
+--! @return public.{{prefix}}_json_entry Matching entry merged with root meta, or NULL.
+CREATE FUNCTION {{prefix}}."->"(e public.{{prefix}}_json_search, selector integer)
+  RETURNS public.{{prefix}}_json_entry
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT CASE
-    WHEN eql_v3_internal.is_ste_vec_array(e) THEN
+    WHEN {{prefix}}_internal.is_ste_vec_array(e) THEN
       -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an
-      -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to
+      -- unknown-typed literal, so `e -> 'sv'` already flattens `public.{{prefix}}_json_search` to
       -- its base type and binds native `jsonb -> text` (see the @warning above) —
-      -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare
+      -- the custom `->(public.{{prefix}}_json_search, text)` operator does NOT capture a bare
       -- untyped literal. The cast documents that intent and guards the `-> selector`
-      -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`
+      -- (integer) hop from ever resolving to the v3 `->(public.{{prefix}}_json_search, integer)`
       -- operator instead of native array access.
-      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry
+      ({{prefix}}.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.{{prefix}}_json_entry
     ELSE NULL
   END
 $$;
 
 CREATE OPERATOR ->(
-  FUNCTION=eql_v3."->",
-  LEFTARG=public.eql_v3_json_search,
+  FUNCTION={{prefix}}."->",
+  LEFTARG=public.{{prefix}}_json_search,
   RIGHTARG=integer
 );
 
@@ -89,37 +89,37 @@ CREATE OPERATOR ->(
 --! Intentional v2 parity: this serializes the entire matched jsonb_entry
 --! object as JSON text. It does not decrypt or return scalar plaintext like
 --! native `jsonb ->>`.
---! @param e public.eql_v3_json_search Encrypted payload.
+--! @param e public.{{prefix}}_json_search Encrypted payload.
 --! @param selector text Field selector hash.
 --! @return text The matching entry as text.
-CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector text)
+CREATE FUNCTION {{prefix}}."->>"(e public.{{prefix}}_json_search, selector text)
   RETURNS text
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3."->"(e, selector)::jsonb::text
+  SELECT {{prefix}}."->"(e, selector)::jsonb::text
 $$;
 
 CREATE OPERATOR ->> (
-  FUNCTION=eql_v3."->>",
-  LEFTARG=public.eql_v3_json_search,
+  FUNCTION={{prefix}}."->>",
+  LEFTARG=public.{{prefix}}_json_search,
   RIGHTARG=text
 );
 
 --! @brief ->> operator with integer array index. Inlinable alias of
 --!        ->(json, integer) coerced to text.
---! @param e public.eql_v3_json_search Encrypted sv-array payload.
+--! @param e public.{{prefix}}_json_search Encrypted sv-array payload.
 --! @param selector integer Array index.
 --! @return text The matching entry as text.
-CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector integer)
+CREATE FUNCTION {{prefix}}."->>"(e public.{{prefix}}_json_search, selector integer)
   RETURNS text
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3."->"(e, selector)::jsonb::text
+  SELECT {{prefix}}."->"(e, selector)::jsonb::text
 $$;
 
 CREATE OPERATOR ->> (
-  FUNCTION=eql_v3."->>",
-  LEFTARG=public.eql_v3_json_search,
+  FUNCTION={{prefix}}."->>",
+  LEFTARG=public.{{prefix}}_json_search,
   RIGHTARG=integer
 );
 
@@ -128,43 +128,43 @@ CREATE OPERATOR ->> (
 ------------------------------------------------------------------------------
 
 --! @brief @> contains operator (document, document).
---! @param a public.eql_v3_json_search Container.
---! @param b public.eql_v3_json_search Contained value.
+--! @param a public.{{prefix}}_json_search Container.
+--! @param b public.{{prefix}}_json_search Contained value.
 --! @return boolean True if a contains b.
---! @see eql_v3.jsonb_document_contains
-CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_search)
+--! @see {{prefix}}.jsonb_document_contains
+CREATE FUNCTION {{prefix}}."@>"(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search)
 RETURNS boolean
 LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.jsonb_document_contains(a, b)
+  SELECT {{prefix}}.jsonb_document_contains(a, b)
 $$;
 
 CREATE OPERATOR @>(
-  FUNCTION=eql_v3."@>",
-  LEFTARG=public.eql_v3_json_search,
-  RIGHTARG=public.eql_v3_json_search
+  FUNCTION={{prefix}}."@>",
+  LEFTARG=public.{{prefix}}_json_search,
+  RIGHTARG=public.{{prefix}}_json_search
 );
 
 --! @brief @> contains operator with an query_json needle.
 --!
---! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a
+--! Inlines to native `jsonb @>` over `{{prefix}}.to_ste_vec_query(a)::jsonb`, so a
 --! functional GIN index on the same expression engages.
 --!
---! @param a public.eql_v3_json_search Container.
---! @param b eql_v3.query_json Query payload.
+--! @param a public.{{prefix}}_json_search Container.
+--! @param b {{prefix}}.query_json Query payload.
 --! @return boolean True if a contains b.
-CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b eql_v3.query_json)
+CREATE FUNCTION {{prefix}}."@>"(a public.{{prefix}}_json_search, b {{prefix}}.query_json)
 RETURNS boolean
 LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.to_ste_vec_query(a)::jsonb
-       @> eql_v3.to_ste_vec_query(b)::jsonb
+  SELECT {{prefix}}.to_ste_vec_query(a)::jsonb
+       @> {{prefix}}.to_ste_vec_query(b)::jsonb
 $$;
 
 CREATE OPERATOR @>(
-  FUNCTION=eql_v3."@>",
-  LEFTARG=public.eql_v3_json_search,
-  RIGHTARG=eql_v3.query_json
+  FUNCTION={{prefix}}."@>",
+  LEFTARG=public.{{prefix}}_json_search,
+  RIGHTARG={{prefix}}.query_json
 );
 
 -- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)
@@ -173,7 +173,7 @@ CREATE OPERATOR @>(
 -- ({s,c,op?}) and carries no value selector, so it can only ever match
 -- structurally ("the document has a node at this path") — value-blind for
 -- bool/null/object/array and op-lossy for number/string. Exact field equality is
--- document containment on the value selector: `col @> $1::eql_v3.query_json`,
+-- document containment on the value selector: `col @> $1::{{prefix}}.query_json`,
 -- where a value-selector's presence in the stored document IS the exact match.
 -- Routing all value equality through that one exact mechanism is why the
 -- structural single-entry behavior (and its `<@` reverse) was blocked.
@@ -183,38 +183,38 @@ CREATE OPERATOR @>(
 ------------------------------------------------------------------------------
 
 --! @brief <@ contained-by operator (document, document).
---! @param a public.eql_v3_json_search Contained value.
---! @param b public.eql_v3_json_search Container.
+--! @param a public.{{prefix}}_json_search Contained value.
+--! @param b public.{{prefix}}_json_search Container.
 --! @return boolean True if a is contained by b.
-CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_search, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}."<@"(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search)
 RETURNS boolean
 LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.to_ste_vec_query(b)::jsonb
-       @> eql_v3.to_ste_vec_query(a)::jsonb
+  SELECT {{prefix}}.to_ste_vec_query(b)::jsonb
+       @> {{prefix}}.to_ste_vec_query(a)::jsonb
 $$;
 
 CREATE OPERATOR <@(
-  FUNCTION=eql_v3."<@",
-  LEFTARG=public.eql_v3_json_search,
-  RIGHTARG=public.eql_v3_json_search
+  FUNCTION={{prefix}}."<@",
+  LEFTARG=public.{{prefix}}_json_search,
+  RIGHTARG=public.{{prefix}}_json_search
 );
 
 --! @brief <@ contained-by operator with an query_json LHS.
---! @param a eql_v3.query_json Query payload.
---! @param b public.eql_v3_json_search Container.
+--! @param a {{prefix}}.query_json Query payload.
+--! @param b public.{{prefix}}_json_search Container.
 --! @return boolean True if b contains a.
-CREATE FUNCTION eql_v3."<@"(a eql_v3.query_json, b public.eql_v3_json_search)
+CREATE FUNCTION {{prefix}}."<@"(a {{prefix}}.query_json, b public.{{prefix}}_json_search)
 RETURNS boolean
 LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3."@>"(b, a)
+  SELECT {{prefix}}."@>"(b, a)
 $$;
 
 CREATE OPERATOR <@(
-  FUNCTION=eql_v3."<@",
-  LEFTARG=eql_v3.query_json,
-  RIGHTARG=public.eql_v3_json_search
+  FUNCTION={{prefix}}."<@",
+  LEFTARG={{prefix}}.query_json,
+  RIGHTARG=public.{{prefix}}_json_search
 );
 
 -- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is
@@ -230,60 +230,60 @@ CREATE OPERATOR <@(
 --!       `bigint`/`numeric`/`text`; exact equality is document containment on a
 --!       value-selector needle. This blocker is deliberately non-STRICT so a
 --!       NULL operand cannot bypass the error.
---! @param a public.eql_v3_json_entry Left operand
---! @param b public.eql_v3_json_entry Right operand
+--! @param a public.{{prefix}}_json_entry Left operand
+--! @param b public.{{prefix}}_json_entry Right operand
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry)
   RETURNS boolean
   IMMUTABLE PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_entry', '=');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG  = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG  = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_entry
 );
 
 --! @brief Block inequality between two extracted jsonb entries.
---! @param a public.eql_v3_json_entry Left operand
---! @param b public.eql_v3_json_entry Right operand
+--! @param a public.{{prefix}}_json_entry Left operand
+--! @param b public.{{prefix}}_json_entry Right operand
 --! @return boolean Never returns; always raises 'operator not supported'.
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry)
   RETURNS boolean
   IMMUTABLE PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
 AS $$
 BEGIN
-  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');
+  RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_entry', '<>');
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG  = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG  = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_entry
 );
 
 --! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).
---! @param a public.eql_v3_json_entry Left operand
---! @param b public.eql_v3_json_entry Right operand
+--! @param a public.{{prefix}}_json_entry Left operand
+--! @param b public.{{prefix}}_json_entry Right operand
 --! @return boolean True if a is less than b
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)
+  SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b)
 $$;
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG  = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG  = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >,
   NEGATOR  = >=,
   RESTRICT = scalarltsel,
@@ -291,20 +291,20 @@ CREATE OPERATOR < (
 );
 
 --! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.
---! @param a public.eql_v3_json_entry Left operand
---! @param b public.eql_v3_json_entry Right operand
+--! @param a public.{{prefix}}_json_entry Left operand
+--! @param b public.{{prefix}}_json_entry Right operand
 --! @return boolean True if a is less than or equal to b
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)
+  SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b)
 $$;
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG  = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG  = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=,
   NEGATOR  = >,
   RESTRICT = scalarlesel,
@@ -312,20 +312,20 @@ CREATE OPERATOR <= (
 );
 
 --! @brief Greater-than on jsonb_entry via the CLLW OPE term.
---! @param a public.eql_v3_json_entry Left operand
---! @param b public.eql_v3_json_entry Right operand
+--! @param a public.{{prefix}}_json_entry Left operand
+--! @param b public.{{prefix}}_json_entry Right operand
 --! @return boolean True if a is greater than b
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)
+  SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b)
 $$;
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG  = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG  = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <,
   NEGATOR  = <=,
   RESTRICT = scalargtsel,
@@ -333,20 +333,20 @@ CREATE OPERATOR > (
 );
 
 --! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.
---! @param a public.eql_v3_json_entry Left operand
---! @param b public.eql_v3_json_entry Right operand
+--! @param a public.{{prefix}}_json_entry Left operand
+--! @param b public.{{prefix}}_json_entry Right operand
 --! @return boolean True if a is greater than or equal to b
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)
+  SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b)
 $$;
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG  = public.eql_v3_json_entry,
-  RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG  = public.{{prefix}}_json_entry,
+  RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=,
   NEGATOR  = <,
   RESTRICT = scalargesel,
diff --git a/packages/eql/src/v3/json/types.sql b/packages/eql/src/v3/json/types.sql
index 0bc34904b..3a676fa48 100644
--- a/packages/eql/src/v3/json/types.sql
+++ b/packages/eql/src/v3/json/types.sql
@@ -1,14 +1,14 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/json/types.sql
---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.
+--! @brief Domain types for the {{prefix}} encrypted-JSONB (SteVec) surface.
 --!
 --! Three jsonb-backed domains (none over another domain — operators resolve
 --! against the ultimate base type jsonb, so the native-jsonb firewall in
 --! blockers.sql can attach):
---!   - public.eql_v3_json_search     — storage/root: an EQL envelope object ({i, v, ...}).
---!   - public.eql_v3_json_entry — a single sv element (returned by `->`).
---!   - eql_v3.query_json  — a containment needle (sv elements, no ciphertext).
+--!   - public.{{prefix}}_json_search     — storage/root: an EQL envelope object ({i, v, ...}).
+--!   - public.{{prefix}}_json_entry — a single sv element (returned by `->`).
+--!   - {{prefix}}.query_json  — a containment needle (sv elements, no ciphertext).
 
 --! @brief Validate a single SteVec entry payload.
 --! @internal
@@ -22,8 +22,8 @@
 --!         a stale `hm`-bearing payload fails loudly rather than degrading to
 --!         a value-less entry. The optional document metadata `i`, `v`, and
 --!         `h` is accepted because selector lookup grafts it onto the entry
---!         before casting to `public.eql_v3_json_entry`.
-CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)
+--!         before casting to `public.{{prefix}}_json_entry`.
+CREATE OR REPLACE FUNCTION public.{{prefix}}_is_valid_ste_vec_entry_payload(val jsonb)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -48,12 +48,12 @@ $$;
 --!         set of selectors — a value-selector's presence in the stored
 --!         document IS the exact value match.
 --! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the
---!   eql_v3.query_json domain CHECK, where a SQL function can never be
+--!   {{prefix}}.query_json domain CHECK, where a SQL function can never be
 --!   inlined (and the CHECK itself cannot absorb this body — it needs a
 --!   subquery over the sv elements, which CHECK constraints forbid). plpgsql
 --!   caches its plan across calls instead of paying the per-call SQL-function
 --!   executor on every needle cast.
-CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)
+CREATE OR REPLACE FUNCTION public.{{prefix}}_is_valid_ste_vec_query_payload(val jsonb)
   RETURNS boolean
   LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -85,21 +85,21 @@ $$;
 --! @internal
 --! @param val jsonb Candidate document payload.
 --! @return boolean True when `val` is an encrypted document envelope with
---!         `v = 3`, `i`, a string key header `h`, an `sv` array, and valid
+--!         `v = {{eql_version}}`, `i`, a string key header `h`, an `sv` array, and valid
 --!         sv entry elements. `h` carries the document's key-retrieval
 --!         material once (every entry encrypts under the document's single
 --!         data key; entry `c` values are raw AEAD output whose nonces are
 --!         derived from the entries' selectors) — it is opaque to SQL and
 --!         only ever carried/grafted, never parsed. Unknown envelope keys are
 --!         rejected; `k` and `a` remain optional compatibility fields.
-CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)
+CREATE OR REPLACE FUNCTION public.{{prefix}}_is_valid_ste_vec_document_payload(val jsonb)
   RETURNS boolean
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT COALESCE(
     jsonb_typeof(val) = 'object'
      AND val ? 'v'
-     AND val ->> 'v' = '3'
+     AND val ->> 'v' = '{{eql_version}}'
      AND val ? 'i'
      AND jsonb_typeof(val -> 'h') = 'string'
      AND jsonb_typeof(val -> 'sv') = 'array'
@@ -109,7 +109,7 @@ AS $$
        FROM jsonb_array_elements(
          CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END
        ) AS elem
-       WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)
+       WHERE NOT public.{{prefix}}_is_valid_ste_vec_entry_payload(elem)
      ),
     false
   )
@@ -117,32 +117,32 @@ $$;
 
 --! @brief Storage/root domain for an encrypted JSONB column.
 --!
---! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index
+--! CHECK: a JSON object carrying the EQL envelope (`v = {{eql_version}}` version, `i` index
 --! metadata, and the key header `h`). Root `c` is intentionally NOT required —
 --! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the
 --! root document ciphertext lives on the root sv entry). The CHECK also
 --! requires an `sv` array, so the domain accepts only SteVec **document**
 --! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`
---! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed
+--! but no `sv`) — this is what keeps `public.{{prefix}}_json_search` a typed
 --! document domain rather than a generic encrypted envelope. The firewall in
 --! blockers.sql attaches to this domain to stop native jsonb operators from
 --! reaching a column value.
 --!
 --! @note Constructing from inline JSON uses the standard DOMAIN cast:
---!       `'{"i":{},"v":3,"h":"...","sv":[...]}'::public.eql_v3_json_search`.
+--!       `'{"i":{},"v":{{eql_version}},"h":"...","sv":[...]}'::public.{{prefix}}_json_search`.
 DO $$
 BEGIN
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_json_search' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_json_search AS jsonb
+    CREATE DOMAIN public.{{prefix}}_json_search AS jsonb
       CHECK (
-        public.eql_v3_is_valid_ste_vec_document_payload(VALUE)
+        public.{{prefix}}_is_valid_ste_vec_document_payload(VALUE)
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';
+  COMMENT ON DOMAIN public.{{prefix}}_json_search IS 'EQL encrypted JSONB searchable document (containment)';
 END
 $$;
 
@@ -154,8 +154,8 @@ $$;
 --! (value-inclusive selectors) and non-orderable path entries are term-less
 --! `{s, c}`: exact matching is selector presence, so there is no per-value
 --! equality term (`hm` is retired and rejected). This is the type returned by
---! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /
---! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases
+--! `->` and accepted by the per-entry extractors `{{prefix}}.ope_term` /
+--! `{{prefix}}.ord_term`. The deprecated `eq_term(json_entry)` name aliases
 --! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`
 --! metadata merged in by `->` are the only additional fields accepted.
 --!
@@ -163,7 +163,7 @@ $$;
 --!
 --! @internal
 --! Implementation note (issue #354): the CHECK is an INLINE expression, not a
---! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain
+--! call to `public.{{prefix}}_is_valid_ste_vec_entry_payload` — domain
 --! constraints cannot inline SQL functions, so the function-call form paid
 --! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle
 --! cast in every field_eq query (+19% end-to-end vs v2, the entire measured
@@ -178,9 +178,9 @@ DO $$
 BEGIN
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_json_entry' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_json_entry AS jsonb
+    CREATE DOMAIN public.{{prefix}}_json_entry AS jsonb
       CHECK (
         VALUE IS NULL
         OR COALESCE(
@@ -196,7 +196,7 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';
 END
 $$;
 
@@ -210,36 +210,36 @@ $$;
 --! casting and matching every row via bare `jsonb @>`.
 --!
 --! @note Construct from inline JSON via the DOMAIN cast:
---!       `'{"sv":[{"s":"<sel>"}]}'::eql_v3.query_json`.
---! @see eql_v3.to_ste_vec_query
+--!       `'{"sv":[{"s":"<sel>"}]}'::{{prefix}}.query_json`.
+--! @see {{prefix}}.to_ste_vec_query
 --!
 --! @internal
 --! Implementation note (issue #354): this CHECK CANNOT be inlined like
---! public.eql_v3_json_entry's — validating the sv elements requires a subquery
+--! public.{{prefix}}_json_entry's — validating the sv elements requires a subquery
 --! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK
 --! constraints forbid subqueries. The validator is plpgsql instead (cached
 --! plan; substantially cheaper per call than a non-inlined LANGUAGE sql
 --! function — the same finding as issue #353), since this cast sits on the
 --! per-query hot path of every containment scenario
---! (`$1::jsonb::eql_v3.query_json`).
+--! (`$1::jsonb::{{prefix}}.query_json`).
 --! @endinternal
 DO $$
 BEGIN
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_json' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_json AS jsonb
+    CREATE DOMAIN {{prefix}}.query_json AS jsonb
       CHECK (
-        public.eql_v3_is_valid_ste_vec_query_payload(VALUE)
+        public.{{prefix}}_is_valid_ste_vec_query_payload(VALUE)
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';
+  COMMENT ON DOMAIN {{prefix}}.query_json IS 'EQL JSONB query operand (containment)';
 END
 $$;
 
---! @brief Convert a public.eql_v3_json_search to a query_json needle.
+--! @brief Convert a public.{{prefix}}_json_search to a query_json needle.
 --!
 --! Normalises each sv element down to its selector `s`. Exact and structural
 --! containment are both selector-set containment; an `op` carried by a legacy
@@ -247,13 +247,13 @@ $$;
 --! but is not part of the containment predicate. Other fields are stripped.
 --! This is the canonical needle shape for `@>` containment and the functional
 --! GIN index expression:
---!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.
+--!   `GIN ({{prefix}}.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.
 --!
---! @param e public.eql_v3_json_search Source encrypted payload
---! @return eql_v3.query_json Query-shaped needle, sv elements normalised.
---! @see eql_v3.query_json
-CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)
-  RETURNS eql_v3.query_json
+--! @param e public.{{prefix}}_json_search Source encrypted payload
+--! @return {{prefix}}.query_json Query-shaped needle, sv elements normalised.
+--! @see {{prefix}}.query_json
+CREATE FUNCTION {{prefix}}.to_ste_vec_query(e public.{{prefix}}_json_search)
+  RETURNS {{prefix}}.query_json
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT jsonb_build_object(
@@ -269,7 +269,7 @@ AS $$
        FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),
       '[]'::jsonb
     )
-  )::eql_v3.query_json
+  )::{{prefix}}.query_json
 $$;
 
 --! @brief Normalise an already query-shaped needle to selector-only form.
@@ -278,8 +278,8 @@ $$;
 --! therefore carry the path entry's `op`. Containment is selector-set
 --! containment, so this overload strips `op` before comparison and keeps every
 --! public containment entry point semantically identical.
-CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)
-  RETURNS eql_v3.query_json
+CREATE FUNCTION {{prefix}}.to_ste_vec_query(e {{prefix}}.query_json)
+  RETURNS {{prefix}}.query_json
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT jsonb_build_object(
@@ -289,9 +289,9 @@ AS $$
        FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),
       '[]'::jsonb
     )
-  )::eql_v3.query_json
+  )::{{prefix}}.query_json
 $$;
 
-CREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)
-  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)
+CREATE CAST (public.{{prefix}}_json_search AS {{prefix}}.query_json)
+  WITH FUNCTION {{prefix}}.to_ste_vec_query(public.{{prefix}}_json_search)
   AS ASSIGNMENT;
diff --git a/packages/eql/src/v3/lint/lints.sql b/packages/eql/src/v3/lint/lints.sql
index 69878bf80..c68307f0c 100644
--- a/packages/eql/src/v3/lint/lints.sql
+++ b/packages/eql/src/v3/lint/lints.sql
@@ -2,7 +2,7 @@
 
 --! @brief EQL lint: detect non-inlinable operator implementation functions
 --!
---! Returns one row per violation found in the installed `eql_v3` surface. The
+--! Returns one row per violation found in the installed `{{prefix}}` surface. The
 --! Postgres planner can only inline a function during index matching when:
 --!
 --!   * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)
@@ -18,11 +18,11 @@
 --! remaining non-inlinable. Implementing the check requires walking `prosrc`
 --! (or `pg_get_functiondef`); tracked as a follow-up.
 --!
---! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and
---! the SEM index-term type `eql_v3_internal.ore_block_256`) whose
+--! Operators on `{{prefix}}` types (the jsonb-backed encrypted-domain families and
+--! the SEM index-term type `{{prefix}}_internal.ore_block_256`) whose
 --! implementation functions fail any of these rules silently fall back to seq
---! scan when the documented functional indexes (`eql_v3.eq_term(col)`,
---! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.
+--! scan when the documented functional indexes (`{{prefix}}.eq_term(col)`,
+--! `{{prefix}}.ord_term(col)`) are in place. This lint surfaces every such case.
 --!
 --! Severity:
 --!   `error`   — fixable, blocks index matching, ship-blocking.
@@ -47,32 +47,32 @@
 --!                                PostgreSQL skips the body and returns NULL
 --!                                on NULL arguments, silently bypassing the
 --!                                RAISE.
---!   `domain_over_domain`      — an `eql_v3` encrypted domain is derived from
+--!   `domain_over_domain`      — an `{{prefix}}` encrypted domain is derived from
 --!                                another encrypted domain rather than jsonb.
 --!                                Operators resolve against the ultimate base
 --!                                type, so the derived domain does not
 --!                                inherit the base domain's blocker surface.
 --!   `domain_opclass`          — an operator class is declared FOR TYPE on an
---!                                `eql_v3` encrypted domain. Opclasses on
+--!                                `{{prefix}}` encrypted domain. Opclasses on
 --!                                domains bypass operator resolution; use a
 --!                                functional index on the extractor instead.
 --!   `schema_placement`        — a naked composite or enum TYPE lives in the
---!                                public `eql_v3` schema. Internal index-term
+--!                                public `{{prefix}}` schema. Internal index-term
 --!                                types (e.g. `ore_block_256_term`) belong in
---!                                `eql_v3_internal`; a composite/enum in
---!                                `eql_v3` clutters the Supabase Table Builder
+--!                                `{{prefix}}_internal`; a composite/enum in
+--!                                `{{prefix}}` clutters the Supabase Table Builder
 --!                                type picker, which the schema split exists to
---!                                prevent. Move it to `eql_v3_internal`.
+--!                                prevent. Move it to `{{prefix}}_internal`.
 --!
 --! @code{.sql}
 --! SELECT severity, category, object_name, message
---!   FROM eql_v3.lints()
+--!   FROM {{prefix}}.lints()
 --!  WHERE severity = 'error'
 --!  ORDER BY category, object_name;
 --! @endcode
 --!
 --! @return SETOF record (severity text, category text, object_name text, message text)
-CREATE OR REPLACE FUNCTION eql_v3.lints()
+CREATE OR REPLACE FUNCTION {{prefix}}.lints()
 RETURNS TABLE (
   severity text,
   category text,
@@ -98,7 +98,7 @@ AS $$
       AND bn.nspname = 'pg_catalog'
       AND (
            dn.nspname = 'public'
-        OR dn.nspname = ANY(eql_v3_internal.owned_schemas())
+        OR dn.nspname = ANY({{prefix}}_internal.owned_schemas())
       )
   ),
 
@@ -118,7 +118,7 @@ AS $$
         SELECT 1 FROM pg_type t
          WHERE t.oid IN (op.oprleft, op.oprright)
            AND (
-                t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))
+                t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY({{prefix}}_internal.owned_schemas()))
              OR t.oid IN (SELECT typid FROM encrypted_domain_types)
            )
       )
@@ -143,7 +143,7 @@ AS $$
     JOIN pg_language lang_l ON lang_l.oid = p.prolang
   ),
 
-  -- Encrypted-domain blockers: functions in `eql_v3` whose body contains
+  -- Encrypted-domain blockers: functions in `{{prefix}}` whose body contains
   -- a blocker marker emitted by the codegen (any of the
   -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean
   -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the
@@ -161,7 +161,7 @@ AS $$
     FROM pg_catalog.pg_proc p
     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
     JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang
-    WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())
+    WHERE n.nspname = ANY({{prefix}}_internal.owned_schemas())
       AND (p.prosrc LIKE '%encrypted_domain_unsupported%'
         OR p.prosrc LIKE '%is not supported for%')
       AND EXISTS (
@@ -343,7 +343,7 @@ AS $$
   JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype
   JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace
   WHERE dt.typtype = 'd'
-    AND dn.nspname = ANY(eql_v3_internal.owned_schemas())
+    AND dn.nspname = ANY({{prefix}}_internal.owned_schemas())
     AND bt.typtype = 'd'
     AND bt.oid IN (SELECT typid FROM encrypted_domain_types)
 
@@ -369,7 +369,7 @@ AS $$
   WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)
 
   -- ┌─────────────────────────────────────────────────────────────────┐
-  -- │ Schema placement: the public `eql_v3` schema must hold only the  │
+  -- │ Schema placement: the public `{{prefix}}` schema must hold only the  │
   -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │
   -- │ there is an internal index-term type in the wrong schema — it     │
   -- │ clutters the Supabase type picker the split exists to keep clean. │
@@ -382,19 +382,19 @@ AS $$
     'schema_placement',
     format('type %I.%I', n.nspname, t.typname),
     format(
-      'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',
+      'Type `%s.%s` is a %s in the public `{{prefix}}` schema. Only jsonb-backed encrypted-domain types belong in `{{prefix}}`; internal index-term types belong in `{{prefix}}_internal` so they stay out of the Supabase Table Builder type picker. Move it to `{{prefix}}_internal`.',
       n.nspname, t.typname,
       CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)
   FROM pg_catalog.pg_type t
   JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  WHERE n.nspname = 'eql_v3'
+  WHERE n.nspname = '{{prefix}}'
     AND t.typtype IN ('c', 'e')
 
   ORDER BY 1, 2, 3;
 $$;
 
-COMMENT ON FUNCTION eql_v3.lints() IS
+COMMENT ON FUNCTION {{prefix}}.lints() IS
   'EQL lint: returns one row per non-inlinable operator implementation. '
-  'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '
-  'CI-gateable check that all operator implementations on eql_v3 types are '
+  'Run `SELECT * FROM {{prefix}}.lints() WHERE severity = ''error''` for a '
+  'CI-gateable check that all operator implementations on {{prefix}} types are '
   'eligible for planner inlining.';
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql
index efa9f30f9..c28ef106c 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/bigint/bigint_eq_functions.sql
---! @brief Functions for public.eql_v3_bigint_eq.
+--! @brief Functions for public.{{prefix}}_bigint_eq.
 
---! @brief Index extractor for public.eql_v3_bigint_eq.
---! @param a public.eql_v3_bigint_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_bigint_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_eq.
---! @param a public.eql_v3_bigint_eq
---! @param b public.eql_v3_bigint_eq
+--! @brief Operator wrapper for public.{{prefix}}_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
+--! @param b public.{{prefix}}_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_eq.
---! @param a public.eql_v3_bigint_eq
+--! @brief Operator wrapper for public.{{prefix}}_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_bigint_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_eq.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_eq.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_eq
+--! @param b public.{{prefix}}_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_bigint_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_eq.
---! @param a public.eql_v3_bigint_eq
---! @param b public.eql_v3_bigint_eq
+--! @brief Operator wrapper for public.{{prefix}}_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
+--! @param b public.{{prefix}}_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_eq.
---! @param a public.eql_v3_bigint_eq
+--! @brief Operator wrapper for public.{{prefix}}_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_bigint_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_eq.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_eq.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_eq
+--! @param b public.{{prefix}}_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_bigint_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text)
-RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$
+--! @return public.{{prefix}}_bigint_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_eq, selector text)
+RETURNS public.{{prefix}}_bigint_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer)
-RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$
+--! @return public.{{prefix}}_bigint_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_eq, selector integer)
+RETURNS public.{{prefix}}_bigint_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_eq right operand of the blocked operator
---! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq)
-RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$
+--! @param selector public.{{prefix}}_bigint_eq right operand of the blocked operator
+--! @return public.{{prefix}}_bigint_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_eq)
+RETURNS public.{{prefix}}_bigint_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql
index 0bb312689..28b4f0c38 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_eq_functions.sql
 
 --! @file encrypted_domain/bigint/bigint_eq_operators.sql
---! @brief Operators for public.eql_v3_bigint_eq.
+--! @brief Operators for public.{{prefix}}_bigint_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_functions.sql
index 1acd0d503..cc2debb8d 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/bigint/bigint_functions.sql
---! @brief Functions for public.eql_v3_bigint.
+--! @brief Functions for public.{{prefix}}_bigint.
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_bigint never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text)
-RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$
+--! @return public.{{prefix}}_bigint never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint, selector text)
+RETURNS public.{{prefix}}_bigint IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_bigint never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer)
-RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$
+--! @return public.{{prefix}}_bigint never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint, selector integer)
+RETURNS public.{{prefix}}_bigint IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint right operand of the blocked operator
---! @return public.eql_v3_bigint never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint)
-RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$
+--! @param selector public.{{prefix}}_bigint right operand of the blocked operator
+--! @return public.{{prefix}}_bigint never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint)
+RETURNS public.{{prefix}}_bigint IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint right operand of the blocked operator
+--! @param selector public.{{prefix}}_bigint right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_operators.sql
index 46170b430..0e1a9e6af 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_functions.sql
 
 --! @file encrypted_domain/bigint/bigint_operators.sql
---! @brief Operators for public.eql_v3_bigint.
+--! @brief Operators for public.{{prefix}}_bigint.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql
index b4d508d87..eedcba3d8 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_operators.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_bigint_ord.
+--! @brief Aggregates for public.{{prefix}}_bigint_ord.
 
---! @brief State function for min on public.eql_v3_bigint_ord.
---! @param state public.eql_v3_bigint_ord
---! @param value public.eql_v3_bigint_ord
---! @return public.eql_v3_bigint_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)
-RETURNS public.eql_v3_bigint_ord
+--! @brief State function for min on public.{{prefix}}_bigint_ord.
+--! @param state public.{{prefix}}_bigint_ord
+--! @param value public.{{prefix}}_bigint_ord
+--! @return public.{{prefix}}_bigint_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_bigint_ord, value public.{{prefix}}_bigint_ord)
+RETURNS public.{{prefix}}_bigint_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_bigint_ord.
---! @param input public.eql_v3_bigint_ord
---! @return public.eql_v3_bigint_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_bigint_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_bigint_ord.
+--! @param input public.{{prefix}}_bigint_ord
+--! @return public.{{prefix}}_bigint_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_bigint_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_bigint_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_bigint_ord.
---! @param state public.eql_v3_bigint_ord
---! @param value public.eql_v3_bigint_ord
---! @return public.eql_v3_bigint_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)
-RETURNS public.eql_v3_bigint_ord
+--! @brief State function for max on public.{{prefix}}_bigint_ord.
+--! @param state public.{{prefix}}_bigint_ord
+--! @param value public.{{prefix}}_bigint_ord
+--! @return public.{{prefix}}_bigint_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_bigint_ord, value public.{{prefix}}_bigint_ord)
+RETURNS public.{{prefix}}_bigint_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_bigint_ord.
---! @param input public.eql_v3_bigint_ord
---! @return public.eql_v3_bigint_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_bigint_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_bigint_ord.
+--! @param input public.{{prefix}}_bigint_ord
+--! @return public.{{prefix}}_bigint_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_bigint_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_bigint_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql
index 77acfe426..ad9b327d0 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_functions.sql
---! @brief Functions for public.eql_v3_bigint_ord.
+--! @brief Functions for public.{{prefix}}_bigint_ord.
 
---! @brief Index extractor for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_bigint_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
---! @param a public.eql_v3_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text)
-RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$
+--! @return public.{{prefix}}_bigint_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord, selector text)
+RETURNS public.{{prefix}}_bigint_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer)
-RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$
+--! @return public.{{prefix}}_bigint_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord, selector integer)
+RETURNS public.{{prefix}}_bigint_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_ord right operand of the blocked operator
---! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord)
-RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$
+--! @param selector public.{{prefix}}_bigint_ord right operand of the blocked operator
+--! @return public.{{prefix}}_bigint_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_ord)
+RETURNS public.{{prefix}}_bigint_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql
index 4e09605c1..58d86e1c6 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_operators.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_bigint_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_bigint_ord_ope.
 
---! @brief State function for min on public.eql_v3_bigint_ord_ope.
---! @param state public.eql_v3_bigint_ord_ope
---! @param value public.eql_v3_bigint_ord_ope
---! @return public.eql_v3_bigint_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)
-RETURNS public.eql_v3_bigint_ord_ope
+--! @brief State function for min on public.{{prefix}}_bigint_ord_ope.
+--! @param state public.{{prefix}}_bigint_ord_ope
+--! @param value public.{{prefix}}_bigint_ord_ope
+--! @return public.{{prefix}}_bigint_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_bigint_ord_ope, value public.{{prefix}}_bigint_ord_ope)
+RETURNS public.{{prefix}}_bigint_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_bigint_ord_ope.
---! @param input public.eql_v3_bigint_ord_ope
---! @return public.eql_v3_bigint_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_bigint_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_bigint_ord_ope.
+--! @param input public.{{prefix}}_bigint_ord_ope
+--! @return public.{{prefix}}_bigint_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_bigint_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_bigint_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_bigint_ord_ope.
---! @param state public.eql_v3_bigint_ord_ope
---! @param value public.eql_v3_bigint_ord_ope
---! @return public.eql_v3_bigint_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)
-RETURNS public.eql_v3_bigint_ord_ope
+--! @brief State function for max on public.{{prefix}}_bigint_ord_ope.
+--! @param state public.{{prefix}}_bigint_ord_ope
+--! @param value public.{{prefix}}_bigint_ord_ope
+--! @return public.{{prefix}}_bigint_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_bigint_ord_ope, value public.{{prefix}}_bigint_ord_ope)
+RETURNS public.{{prefix}}_bigint_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_bigint_ord_ope.
---! @param input public.eql_v3_bigint_ord_ope
---! @return public.eql_v3_bigint_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_bigint_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_bigint_ord_ope.
+--! @param input public.{{prefix}}_bigint_ord_ope
+--! @return public.{{prefix}}_bigint_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_bigint_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_bigint_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql
index 478a60db1..70ef50924 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_bigint_ord_ope.
+--! @brief Functions for public.{{prefix}}_bigint_ord_ope.
 
---! @brief Index extractor for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_bigint_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text)
-RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$
+--! @return public.{{prefix}}_bigint_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ope, selector text)
+RETURNS public.{{prefix}}_bigint_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer)
-RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$
+--! @return public.{{prefix}}_bigint_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ope, selector integer)
+RETURNS public.{{prefix}}_bigint_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator
---! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope)
-RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_bigint_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_ord_ope)
+RETURNS public.{{prefix}}_bigint_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql
index 65c515f20..32e990646 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_functions.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_bigint_ord_ope.
+--! @brief Operators for public.{{prefix}}_bigint_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql
index c86e76306..9742bc09c 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_functions.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_operators.sql
---! @brief Operators for public.eql_v3_bigint_ord.
+--! @brief Operators for public.{{prefix}}_bigint_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql
index 685bc67a9..821641457 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_operators.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_bigint_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_bigint_ord_ore.
 
---! @brief State function for min on public.eql_v3_bigint_ord_ore.
---! @param state public.eql_v3_bigint_ord_ore
---! @param value public.eql_v3_bigint_ord_ore
---! @return public.eql_v3_bigint_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)
-RETURNS public.eql_v3_bigint_ord_ore
+--! @brief State function for min on public.{{prefix}}_bigint_ord_ore.
+--! @param state public.{{prefix}}_bigint_ord_ore
+--! @param value public.{{prefix}}_bigint_ord_ore
+--! @return public.{{prefix}}_bigint_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_bigint_ord_ore, value public.{{prefix}}_bigint_ord_ore)
+RETURNS public.{{prefix}}_bigint_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_bigint_ord_ore.
---! @param input public.eql_v3_bigint_ord_ore
---! @return public.eql_v3_bigint_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_bigint_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_bigint_ord_ore.
+--! @param input public.{{prefix}}_bigint_ord_ore
+--! @return public.{{prefix}}_bigint_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_bigint_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_bigint_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_bigint_ord_ore.
---! @param state public.eql_v3_bigint_ord_ore
---! @param value public.eql_v3_bigint_ord_ore
---! @return public.eql_v3_bigint_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)
-RETURNS public.eql_v3_bigint_ord_ore
+--! @brief State function for max on public.{{prefix}}_bigint_ord_ore.
+--! @param state public.{{prefix}}_bigint_ord_ore
+--! @param value public.{{prefix}}_bigint_ord_ore
+--! @return public.{{prefix}}_bigint_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_bigint_ord_ore, value public.{{prefix}}_bigint_ord_ore)
+RETURNS public.{{prefix}}_bigint_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_bigint_ord_ore.
---! @param input public.eql_v3_bigint_ord_ore
---! @return public.eql_v3_bigint_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_bigint_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_bigint_ord_ore.
+--! @param input public.{{prefix}}_bigint_ord_ore
+--! @return public.{{prefix}}_bigint_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_bigint_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_bigint_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql
index 0441c8186..c2856dba4 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_bigint_ord_ore.
+--! @brief Functions for public.{{prefix}}_bigint_ord_ore.
 
---! @brief Index extractor for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_bigint_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text)
-RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$
+--! @return public.{{prefix}}_bigint_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ore, selector text)
+RETURNS public.{{prefix}}_bigint_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer)
-RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$
+--! @return public.{{prefix}}_bigint_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ore, selector integer)
+RETURNS public.{{prefix}}_bigint_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator
---! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore)
-RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_bigint_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_ord_ore)
+RETURNS public.{{prefix}}_bigint_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql
index 2f87146cc..3894c846f 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_functions.sql
 
 --! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_bigint_ord_ore.
+--! @brief Operators for public.{{prefix}}_bigint_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/bigint/bigint_types.sql b/packages/eql/src/v3/scalars/bigint/bigint_types.sql
index 940c301f5..fd257d7f9 100644
--- a/packages/eql/src/v3/scalars/bigint/bigint_types.sql
+++ b/packages/eql/src/v3/scalars/bigint/bigint_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_bigint.
+  --! @brief Encrypted domain public.{{prefix}}_bigint.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_bigint' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_bigint AS jsonb
+    CREATE DOMAIN public.{{prefix}}_bigint AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_bigint IS 'EQL encrypted bigint (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_bigint_eq.
+  --! @brief Encrypted domain public.{{prefix}}_bigint_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_bigint_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_bigint_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_bigint_eq IS 'EQL encrypted bigint (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_bigint_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_bigint_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_bigint_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_bigint_ord.
+  --! @brief Encrypted domain public.{{prefix}}_bigint_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_bigint_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_bigint_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_bigint_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_bigint_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_bigint_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql
index 3ee50c424..da47e1897 100644
--- a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql
@@ -7,244 +7,244 @@
 -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
 
 --! @file encrypted_domain/bigint/json_entry_bigint_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_bigint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_bigint_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_bigint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_bigint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_bigint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_bigint_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_bigint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_bigint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_bigint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_bigint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql
index cc44db7ce..3403a3c1f 100644
--- a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql
@@ -5,140 +5,140 @@
 -- REQUIRE: src/v3/scalars/bigint/json_entry_bigint_functions.sql
 
 --! @file encrypted_domain/bigint/json_entry_bigint_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql
index 7efa82837..7983a84ae 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_eq_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_eq_functions.sql
---! @brief Functions for eql_v3.query_bigint_eq.
+--! @brief Functions for {{prefix}}.query_bigint_eq.
 
---! @brief Index extractor for eql_v3.query_bigint_eq.
---! @param a eql_v3.query_bigint_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_bigint_eq.
+--! @param a {{prefix}}.query_bigint_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_bigint_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_eq.
---! @param a public.eql_v3_bigint_eq
---! @param b eql_v3.query_bigint_eq
+--! @brief Operator wrapper for {{prefix}}.query_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
+--! @param b {{prefix}}.query_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_eq, b {{prefix}}.query_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_eq.
---! @param a eql_v3.query_bigint_eq
---! @param b public.eql_v3_bigint_eq
+--! @brief Operator wrapper for {{prefix}}.query_bigint_eq.
+--! @param a {{prefix}}.query_bigint_eq
+--! @param b public.{{prefix}}_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_eq.
---! @param a public.eql_v3_bigint_eq
---! @param b eql_v3.query_bigint_eq
+--! @brief Operator wrapper for {{prefix}}.query_bigint_eq.
+--! @param a public.{{prefix}}_bigint_eq
+--! @param b {{prefix}}.query_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_eq, b {{prefix}}.query_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_eq.
---! @param a eql_v3.query_bigint_eq
---! @param b public.eql_v3_bigint_eq
+--! @brief Operator wrapper for {{prefix}}.query_bigint_eq.
+--! @param a {{prefix}}.query_bigint_eq
+--! @param b public.{{prefix}}_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_eq, b public.{{prefix}}_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql
index 76f9908ec..d726740a7 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/bigint/query_bigint_eq_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_eq_operators.sql
---! @brief Operators for eql_v3.query_bigint_eq.
+--! @brief Operators for {{prefix}}.query_bigint_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = {{prefix}}.query_bigint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = {{prefix}}.query_bigint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql
index 4fbd3e16b..c85509ab2 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_ord_functions.sql
---! @brief Functions for eql_v3.query_bigint_ord.
+--! @brief Functions for {{prefix}}.query_bigint_ord.
 
---! @brief Index extractor for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_bigint_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a public.eql_v3_bigint_ord
---! @param b eql_v3.query_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a public.{{prefix}}_bigint_ord
+--! @param b {{prefix}}.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord.
---! @param a eql_v3.query_bigint_ord
---! @param b public.eql_v3_bigint_ord
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord.
+--! @param a {{prefix}}.query_bigint_ord
+--! @param b public.{{prefix}}_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
index c28bec13a..6315451b9 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_bigint_ord_ope.
+--! @brief Functions for {{prefix}}.query_bigint_ord_ope.
 
---! @brief Index extractor for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_bigint_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a public.eql_v3_bigint_ord_ope
---! @param b eql_v3.query_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a public.{{prefix}}_bigint_ord_ope
+--! @param b {{prefix}}.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
---! @param a eql_v3.query_bigint_ord_ope
---! @param b public.eql_v3_bigint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope.
+--! @param a {{prefix}}.query_bigint_ord_ope
+--! @param b public.{{prefix}}_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql
index 7e58ae385..2f01b668a 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_bigint_ord_ope.
+--! @brief Operators for {{prefix}}.query_bigint_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql
index 9bbb5f8d0..42274269f 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_ord_operators.sql
---! @brief Operators for eql_v3.query_bigint_ord.
+--! @brief Operators for {{prefix}}.query_bigint_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
index 9b90cc642..c1dec7671 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_bigint_ord_ore.
+--! @brief Functions for {{prefix}}.query_bigint_ord_ore.
 
---! @brief Index extractor for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_bigint_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b eql_v3.query_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b {{prefix}}.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b eql_v3.query_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b {{prefix}}.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b eql_v3.query_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b {{prefix}}.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b eql_v3.query_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b {{prefix}}.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b eql_v3.query_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b {{prefix}}.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a public.eql_v3_bigint_ord_ore
---! @param b eql_v3.query_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a public.{{prefix}}_bigint_ord_ore
+--! @param b {{prefix}}.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
---! @param a eql_v3.query_bigint_ord_ore
---! @param b public.eql_v3_bigint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore.
+--! @param a {{prefix}}.query_bigint_ord_ore
+--! @param b public.{{prefix}}_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql
index d672cfe57..a86c28310 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
 
 --! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_bigint_ord_ore.
+--! @brief Operators for {{prefix}}.query_bigint_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql
index fbffb8c40..d1d4e14ed 100644
--- a/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql
+++ b/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/bigint/query_bigint_types.sql
 --! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_bigint_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_bigint_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_bigint_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_bigint_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_bigint_eq IS 'EQL bigint query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_bigint_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_bigint_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_bigint_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_bigint_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_bigint_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_bigint_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_bigint_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_bigint_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_bigint_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/boolean/boolean_functions.sql b/packages/eql/src/v3/scalars/boolean/boolean_functions.sql
index c34730227..e3414420f 100644
--- a/packages/eql/src/v3/scalars/boolean/boolean_functions.sql
+++ b/packages/eql/src/v3/scalars/boolean/boolean_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/boolean/boolean_functions.sql
---! @brief Functions for public.eql_v3_boolean.
+--! @brief Functions for public.{{prefix}}_boolean.
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text)
-RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$
+--! @return public.{{prefix}}_boolean never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_boolean, selector text)
+RETURNS public.{{prefix}}_boolean IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer)
-RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$
+--! @return public.{{prefix}}_boolean never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_boolean, selector integer)
+RETURNS public.{{prefix}}_boolean IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_boolean right operand of the blocked operator
---! @return public.eql_v3_boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean)
-RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$
+--! @param selector public.{{prefix}}_boolean right operand of the blocked operator
+--! @return public.{{prefix}}_boolean never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_boolean)
+RETURNS public.{{prefix}}_boolean IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_boolean, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_boolean, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_boolean right operand of the blocked operator
+--! @param selector public.{{prefix}}_boolean right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_boolean)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_boolean, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_boolean, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_boolean, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_boolean, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_boolean, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_boolean)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_boolean, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_boolean, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_boolean, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_boolean, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_boolean, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_boolean, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_boolean, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_boolean left operand of the blocked operator
+--! @param a public.{{prefix}}_boolean left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_boolean, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_boolean.
+--! @brief Unsupported operator blocker for public.{{prefix}}_boolean.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_boolean right operand of the blocked operator
+--! @param b public.{{prefix}}_boolean right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_boolean)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_boolean'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/boolean/boolean_operators.sql b/packages/eql/src/v3/scalars/boolean/boolean_operators.sql
index 004793512..d7a3d00e4 100644
--- a/packages/eql/src/v3/scalars/boolean/boolean_operators.sql
+++ b/packages/eql/src/v3/scalars/boolean/boolean_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/boolean/boolean_functions.sql
 
 --! @file encrypted_domain/boolean/boolean_operators.sql
---! @brief Operators for public.eql_v3_boolean.
+--! @brief Operators for public.{{prefix}}_boolean.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean
 );
diff --git a/packages/eql/src/v3/scalars/boolean/boolean_types.sql b/packages/eql/src/v3/scalars/boolean/boolean_types.sql
index 755c68df4..217adc946 100644
--- a/packages/eql/src/v3/scalars/boolean/boolean_types.sql
+++ b/packages/eql/src/v3/scalars/boolean/boolean_types.sql
@@ -6,21 +6,21 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_boolean.
+  --! @brief Encrypted domain public.{{prefix}}_boolean.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_boolean' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_boolean AS jsonb
+    CREATE DOMAIN public.{{prefix}}_boolean AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_boolean IS 'EQL encrypted boolean (storage only)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/date/date_eq_functions.sql b/packages/eql/src/v3/scalars/date/date_eq_functions.sql
index c72d2b9d1..ca4cd6750 100644
--- a/packages/eql/src/v3/scalars/date/date_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/date/date_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/date/date_eq_functions.sql
---! @brief Functions for public.eql_v3_date_eq.
+--! @brief Functions for public.{{prefix}}_date_eq.
 
---! @brief Index extractor for public.eql_v3_date_eq.
---! @param a public.eql_v3_date_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_date_eq.
+--! @param a public.{{prefix}}_date_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_date_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_eq.
---! @param a public.eql_v3_date_eq
---! @param b public.eql_v3_date_eq
+--! @brief Operator wrapper for public.{{prefix}}_date_eq.
+--! @param a public.{{prefix}}_date_eq
+--! @param b public.{{prefix}}_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_eq.
---! @param a public.eql_v3_date_eq
+--! @brief Operator wrapper for public.{{prefix}}_date_eq.
+--! @param a public.{{prefix}}_date_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_date_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_eq.
+--! @brief Operator wrapper for public.{{prefix}}_date_eq.
 --! @param a jsonb
---! @param b public.eql_v3_date_eq
+--! @param b public.{{prefix}}_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_date_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_eq.
---! @param a public.eql_v3_date_eq
---! @param b public.eql_v3_date_eq
+--! @brief Operator wrapper for public.{{prefix}}_date_eq.
+--! @param a public.{{prefix}}_date_eq
+--! @param b public.{{prefix}}_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_eq.
---! @param a public.eql_v3_date_eq
+--! @brief Operator wrapper for public.{{prefix}}_date_eq.
+--! @param a public.{{prefix}}_date_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_date_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_eq.
+--! @brief Operator wrapper for public.{{prefix}}_date_eq.
 --! @param a jsonb
---! @param b public.eql_v3_date_eq
+--! @param b public.{{prefix}}_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_date_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text)
-RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$
+--! @return public.{{prefix}}_date_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_eq, selector text)
+RETURNS public.{{prefix}}_date_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer)
-RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$
+--! @return public.{{prefix}}_date_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_eq, selector integer)
+RETURNS public.{{prefix}}_date_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_eq right operand of the blocked operator
---! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq)
-RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$
+--! @param selector public.{{prefix}}_date_eq right operand of the blocked operator
+--! @return public.{{prefix}}_date_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_eq)
+RETURNS public.{{prefix}}_date_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_date_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_date_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/date/date_eq_operators.sql b/packages/eql/src/v3/scalars/date/date_eq_operators.sql
index 6fa719cc4..17ec9d4a2 100644
--- a/packages/eql/src/v3/scalars/date/date_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/date/date_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/date/date_eq_functions.sql
 
 --! @file encrypted_domain/date/date_eq_operators.sql
---! @brief Operators for public.eql_v3_date_eq.
+--! @brief Operators for public.{{prefix}}_date_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq
 );
diff --git a/packages/eql/src/v3/scalars/date/date_functions.sql b/packages/eql/src/v3/scalars/date/date_functions.sql
index 463bbdca5..0ac101353 100644
--- a/packages/eql/src/v3/scalars/date/date_functions.sql
+++ b/packages/eql/src/v3/scalars/date/date_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/date/date_functions.sql
---! @brief Functions for public.eql_v3_date.
+--! @brief Functions for public.{{prefix}}_date.
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_date never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text)
-RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$
+--! @return public.{{prefix}}_date never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date, selector text)
+RETURNS public.{{prefix}}_date IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_date never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer)
-RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$
+--! @return public.{{prefix}}_date never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date, selector integer)
+RETURNS public.{{prefix}}_date IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date right operand of the blocked operator
---! @return public.eql_v3_date never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date)
-RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$
+--! @param selector public.{{prefix}}_date right operand of the blocked operator
+--! @return public.{{prefix}}_date never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date)
+RETURNS public.{{prefix}}_date IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date right operand of the blocked operator
+--! @param selector public.{{prefix}}_date right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date, b public.{{prefix}}_date)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date left operand of the blocked operator
+--! @param a public.{{prefix}}_date left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date right operand of the blocked operator
+--! @param b public.{{prefix}}_date right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/date/date_operators.sql b/packages/eql/src/v3/scalars/date/date_operators.sql
index daad33efe..bc651c657 100644
--- a/packages/eql/src/v3/scalars/date/date_operators.sql
+++ b/packages/eql/src/v3/scalars/date/date_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/date/date_functions.sql
 
 --! @file encrypted_domain/date/date_operators.sql
---! @brief Operators for public.eql_v3_date.
+--! @brief Operators for public.{{prefix}}_date.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_date, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date
 );
diff --git a/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql b/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql
index c3050d373..17fc17831 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_operators.sql
 
 --! @file encrypted_domain/date/date_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_date_ord.
+--! @brief Aggregates for public.{{prefix}}_date_ord.
 
---! @brief State function for min on public.eql_v3_date_ord.
---! @param state public.eql_v3_date_ord
---! @param value public.eql_v3_date_ord
---! @return public.eql_v3_date_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)
-RETURNS public.eql_v3_date_ord
+--! @brief State function for min on public.{{prefix}}_date_ord.
+--! @param state public.{{prefix}}_date_ord
+--! @param value public.{{prefix}}_date_ord
+--! @return public.{{prefix}}_date_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_date_ord, value public.{{prefix}}_date_ord)
+RETURNS public.{{prefix}}_date_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_date_ord.
---! @param input public.eql_v3_date_ord
---! @return public.eql_v3_date_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_date_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_date_ord.
+--! @param input public.{{prefix}}_date_ord
+--! @return public.{{prefix}}_date_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_date_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_date_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_date_ord.
---! @param state public.eql_v3_date_ord
---! @param value public.eql_v3_date_ord
---! @return public.eql_v3_date_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)
-RETURNS public.eql_v3_date_ord
+--! @brief State function for max on public.{{prefix}}_date_ord.
+--! @param state public.{{prefix}}_date_ord
+--! @param value public.{{prefix}}_date_ord
+--! @return public.{{prefix}}_date_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_date_ord, value public.{{prefix}}_date_ord)
+RETURNS public.{{prefix}}_date_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_date_ord.
---! @param input public.eql_v3_date_ord
---! @return public.eql_v3_date_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_date_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_date_ord.
+--! @param input public.{{prefix}}_date_ord
+--! @return public.{{prefix}}_date_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_date_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_date_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/date/date_ord_functions.sql b/packages/eql/src/v3/scalars/date/date_ord_functions.sql
index baf000ced..859031af8 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/date/date_ord_functions.sql
---! @brief Functions for public.eql_v3_date_ord.
+--! @brief Functions for public.{{prefix}}_date_ord.
 
---! @brief Index extractor for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_date_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
---! @param a public.eql_v3_date_ord
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
+--! @param a public.{{prefix}}_date_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text)
-RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$
+--! @return public.{{prefix}}_date_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord, selector text)
+RETURNS public.{{prefix}}_date_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer)
-RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$
+--! @return public.{{prefix}}_date_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord, selector integer)
+RETURNS public.{{prefix}}_date_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_ord right operand of the blocked operator
---! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord)
-RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$
+--! @param selector public.{{prefix}}_date_ord right operand of the blocked operator
+--! @return public.{{prefix}}_date_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_ord)
+RETURNS public.{{prefix}}_date_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql
index 7f2908c0c..26fa57f22 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_ope_operators.sql
 
 --! @file encrypted_domain/date/date_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_date_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_date_ord_ope.
 
---! @brief State function for min on public.eql_v3_date_ord_ope.
---! @param state public.eql_v3_date_ord_ope
---! @param value public.eql_v3_date_ord_ope
---! @return public.eql_v3_date_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)
-RETURNS public.eql_v3_date_ord_ope
+--! @brief State function for min on public.{{prefix}}_date_ord_ope.
+--! @param state public.{{prefix}}_date_ord_ope
+--! @param value public.{{prefix}}_date_ord_ope
+--! @return public.{{prefix}}_date_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_date_ord_ope, value public.{{prefix}}_date_ord_ope)
+RETURNS public.{{prefix}}_date_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_date_ord_ope.
---! @param input public.eql_v3_date_ord_ope
---! @return public.eql_v3_date_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_date_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_date_ord_ope.
+--! @param input public.{{prefix}}_date_ord_ope
+--! @return public.{{prefix}}_date_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_date_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_date_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_date_ord_ope.
---! @param state public.eql_v3_date_ord_ope
---! @param value public.eql_v3_date_ord_ope
---! @return public.eql_v3_date_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)
-RETURNS public.eql_v3_date_ord_ope
+--! @brief State function for max on public.{{prefix}}_date_ord_ope.
+--! @param state public.{{prefix}}_date_ord_ope
+--! @param value public.{{prefix}}_date_ord_ope
+--! @return public.{{prefix}}_date_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_date_ord_ope, value public.{{prefix}}_date_ord_ope)
+RETURNS public.{{prefix}}_date_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_date_ord_ope.
---! @param input public.eql_v3_date_ord_ope
---! @return public.eql_v3_date_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_date_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_date_ord_ope.
+--! @param input public.{{prefix}}_date_ord_ope
+--! @return public.{{prefix}}_date_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_date_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_date_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql b/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql
index 9cc2a88d0..c64f82300 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/date/date_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_date_ord_ope.
+--! @brief Functions for public.{{prefix}}_date_ord_ope.
 
---! @brief Index extractor for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_date_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text)
-RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$
+--! @return public.{{prefix}}_date_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ope, selector text)
+RETURNS public.{{prefix}}_date_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer)
-RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$
+--! @return public.{{prefix}}_date_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ope, selector integer)
+RETURNS public.{{prefix}}_date_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator
---! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope)
-RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_date_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_date_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_ord_ope)
+RETURNS public.{{prefix}}_date_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql b/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql
index b511e73a0..6a5ce6b96 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_ope_functions.sql
 
 --! @file encrypted_domain/date/date_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_date_ord_ope.
+--! @brief Operators for public.{{prefix}}_date_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/date/date_ord_operators.sql b/packages/eql/src/v3/scalars/date/date_ord_operators.sql
index 28e0bac49..bed1b234d 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_functions.sql
 
 --! @file encrypted_domain/date/date_ord_operators.sql
---! @brief Operators for public.eql_v3_date_ord.
+--! @brief Operators for public.{{prefix}}_date_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord
 );
diff --git a/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql
index bcc6aa22b..1cbcd8125 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_ore_operators.sql
 
 --! @file encrypted_domain/date/date_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_date_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_date_ord_ore.
 
---! @brief State function for min on public.eql_v3_date_ord_ore.
---! @param state public.eql_v3_date_ord_ore
---! @param value public.eql_v3_date_ord_ore
---! @return public.eql_v3_date_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)
-RETURNS public.eql_v3_date_ord_ore
+--! @brief State function for min on public.{{prefix}}_date_ord_ore.
+--! @param state public.{{prefix}}_date_ord_ore
+--! @param value public.{{prefix}}_date_ord_ore
+--! @return public.{{prefix}}_date_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_date_ord_ore, value public.{{prefix}}_date_ord_ore)
+RETURNS public.{{prefix}}_date_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_date_ord_ore.
---! @param input public.eql_v3_date_ord_ore
---! @return public.eql_v3_date_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_date_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_date_ord_ore.
+--! @param input public.{{prefix}}_date_ord_ore
+--! @return public.{{prefix}}_date_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_date_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_date_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_date_ord_ore.
---! @param state public.eql_v3_date_ord_ore
---! @param value public.eql_v3_date_ord_ore
---! @return public.eql_v3_date_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)
-RETURNS public.eql_v3_date_ord_ore
+--! @brief State function for max on public.{{prefix}}_date_ord_ore.
+--! @param state public.{{prefix}}_date_ord_ore
+--! @param value public.{{prefix}}_date_ord_ore
+--! @return public.{{prefix}}_date_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_date_ord_ore, value public.{{prefix}}_date_ord_ore)
+RETURNS public.{{prefix}}_date_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_date_ord_ore.
---! @param input public.eql_v3_date_ord_ore
---! @return public.eql_v3_date_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_date_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_date_ord_ore.
+--! @param input public.{{prefix}}_date_ord_ore
+--! @return public.{{prefix}}_date_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_date_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_date_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql b/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql
index a84903fb3..676c12d33 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/date/date_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_date_ord_ore.
+--! @brief Functions for public.{{prefix}}_date_ord_ore.
 
---! @brief Index extractor for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_date_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_date_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text)
-RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$
+--! @return public.{{prefix}}_date_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ore, selector text)
+RETURNS public.{{prefix}}_date_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer)
-RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$
+--! @return public.{{prefix}}_date_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ore, selector integer)
+RETURNS public.{{prefix}}_date_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator
---! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore)
-RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_date_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_date_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_ord_ore)
+RETURNS public.{{prefix}}_date_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql b/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql
index 28a9cc7ed..a248fbfc1 100644
--- a/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_ore_functions.sql
 
 --! @file encrypted_domain/date/date_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_date_ord_ore.
+--! @brief Operators for public.{{prefix}}_date_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/date/date_types.sql b/packages/eql/src/v3/scalars/date/date_types.sql
index 88675a024..8ad3cb4ba 100644
--- a/packages/eql/src/v3/scalars/date/date_types.sql
+++ b/packages/eql/src/v3/scalars/date/date_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_date.
+  --! @brief Encrypted domain public.{{prefix}}_date.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_date' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_date AS jsonb
+    CREATE DOMAIN public.{{prefix}}_date AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_date IS 'EQL encrypted date (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_date_eq.
+  --! @brief Encrypted domain public.{{prefix}}_date_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_date_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_date_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_date_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_date_eq IS 'EQL encrypted date (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_date_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_date_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_date_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_date_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_date_ord_ore IS 'EQL encrypted date (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_date_ord.
+  --! @brief Encrypted domain public.{{prefix}}_date_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_date_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_date_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_date_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_date_ord IS 'EQL encrypted date (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_date_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_date_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_date_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_date_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_date_ord_ope IS 'EQL encrypted date (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql b/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql
index afbaad93e..9e9f91635 100644
--- a/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql
+++ b/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql
@@ -5,340 +5,340 @@
 -- REQUIRE: src/v3/scalars/date/query_date_types.sql
 
 --! @file encrypted_domain/date/json_entry_date_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql b/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql
index 21d15ef62..70cbcf9c8 100644
--- a/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql
+++ b/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql
@@ -5,124 +5,124 @@
 -- REQUIRE: src/v3/scalars/date/json_entry_date_functions.sql
 
 --! @file encrypted_domain/date/json_entry_date_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
diff --git a/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql b/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql
index ca139e143..11dc75212 100644
--- a/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/date/date_eq_functions.sql
 
 --! @file encrypted_domain/date/query_date_eq_functions.sql
---! @brief Functions for eql_v3.query_date_eq.
+--! @brief Functions for {{prefix}}.query_date_eq.
 
---! @brief Index extractor for eql_v3.query_date_eq.
---! @param a eql_v3.query_date_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_date_eq.
+--! @param a {{prefix}}.query_date_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_date_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_eq.
---! @param a public.eql_v3_date_eq
---! @param b eql_v3.query_date_eq
+--! @brief Operator wrapper for {{prefix}}.query_date_eq.
+--! @param a public.{{prefix}}_date_eq
+--! @param b {{prefix}}.query_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_eq, b {{prefix}}.query_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_eq.
---! @param a eql_v3.query_date_eq
---! @param b public.eql_v3_date_eq
+--! @brief Operator wrapper for {{prefix}}.query_date_eq.
+--! @param a {{prefix}}.query_date_eq
+--! @param b public.{{prefix}}_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_eq.
---! @param a public.eql_v3_date_eq
---! @param b eql_v3.query_date_eq
+--! @brief Operator wrapper for {{prefix}}.query_date_eq.
+--! @param a public.{{prefix}}_date_eq
+--! @param b {{prefix}}.query_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_eq, b {{prefix}}.query_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_eq.
---! @param a eql_v3.query_date_eq
---! @param b public.eql_v3_date_eq
+--! @brief Operator wrapper for {{prefix}}.query_date_eq.
+--! @param a {{prefix}}.query_date_eq
+--! @param b public.{{prefix}}_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_eq, b public.{{prefix}}_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql b/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql
index 9fe762f09..fac95ee10 100644
--- a/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/date/query_date_eq_functions.sql
 
 --! @file encrypted_domain/date/query_date_eq_operators.sql
---! @brief Operators for eql_v3.query_date_eq.
+--! @brief Operators for {{prefix}}.query_date_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = {{prefix}}.query_date_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_date_eq, RIGHTARG = public.{{prefix}}_date_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = {{prefix}}.query_date_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_date_eq, RIGHTARG = public.{{prefix}}_date_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql b/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql
index ca717c325..856f51cea 100644
--- a/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_functions.sql
 
 --! @file encrypted_domain/date/query_date_ord_functions.sql
---! @brief Functions for eql_v3.query_date_ord.
+--! @brief Functions for {{prefix}}.query_date_ord.
 
---! @brief Index extractor for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_date_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b eql_v3.query_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b {{prefix}}.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b eql_v3.query_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b {{prefix}}.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b eql_v3.query_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b {{prefix}}.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b eql_v3.query_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b {{prefix}}.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b eql_v3.query_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b {{prefix}}.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a public.eql_v3_date_ord
---! @param b eql_v3.query_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a public.{{prefix}}_date_ord
+--! @param b {{prefix}}.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord.
---! @param a eql_v3.query_date_ord
---! @param b public.eql_v3_date_ord
+--! @brief Operator wrapper for {{prefix}}.query_date_ord.
+--! @param a {{prefix}}.query_date_ord
+--! @param b public.{{prefix}}_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql
index 12c031721..f8c65dff7 100644
--- a/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_ope_functions.sql
 
 --! @file encrypted_domain/date/query_date_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_date_ord_ope.
+--! @brief Functions for {{prefix}}.query_date_ord_ope.
 
---! @brief Index extractor for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_date_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b eql_v3.query_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b {{prefix}}.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b eql_v3.query_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b {{prefix}}.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b eql_v3.query_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b {{prefix}}.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b eql_v3.query_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b {{prefix}}.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b eql_v3.query_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b {{prefix}}.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a public.eql_v3_date_ord_ope
---! @param b eql_v3.query_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a public.{{prefix}}_date_ord_ope
+--! @param b {{prefix}}.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ope.
---! @param a eql_v3.query_date_ord_ope
---! @param b public.eql_v3_date_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope.
+--! @param a {{prefix}}.query_date_ord_ope
+--! @param b public.{{prefix}}_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql
index 02b85da2b..c1de6b14c 100644
--- a/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/date/query_date_ord_ope_functions.sql
 
 --! @file encrypted_domain/date/query_date_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_date_ord_ope.
+--! @brief Operators for {{prefix}}.query_date_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql b/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql
index 94d0cdf44..c555e1b20 100644
--- a/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/date/query_date_ord_functions.sql
 
 --! @file encrypted_domain/date/query_date_ord_operators.sql
---! @brief Operators for eql_v3.query_date_ord.
+--! @brief Operators for {{prefix}}.query_date_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql
index d2a155a4f..c06aebf87 100644
--- a/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/date/date_ord_ore_functions.sql
 
 --! @file encrypted_domain/date/query_date_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_date_ord_ore.
+--! @brief Functions for {{prefix}}.query_date_ord_ore.
 
---! @brief Index extractor for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_date_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b eql_v3.query_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b {{prefix}}.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b eql_v3.query_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b {{prefix}}.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b eql_v3.query_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b {{prefix}}.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b eql_v3.query_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b {{prefix}}.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b eql_v3.query_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b {{prefix}}.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a public.eql_v3_date_ord_ore
---! @param b eql_v3.query_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a public.{{prefix}}_date_ord_ore
+--! @param b {{prefix}}.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_date_ord_ore.
---! @param a eql_v3.query_date_ord_ore
---! @param b public.eql_v3_date_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore.
+--! @param a {{prefix}}.query_date_ord_ore
+--! @param b public.{{prefix}}_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql
index 06b065845..4e22bab87 100644
--- a/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/date/query_date_ord_ore_functions.sql
 
 --! @file encrypted_domain/date/query_date_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_date_ord_ore.
+--! @brief Operators for {{prefix}}.query_date_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/date/query_date_types.sql b/packages/eql/src/v3/scalars/date/query_date_types.sql
index 68b3bae1d..1f2f4edbf 100644
--- a/packages/eql/src/v3/scalars/date/query_date_types.sql
+++ b/packages/eql/src/v3/scalars/date/query_date_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/date/query_date_types.sql
 --! @brief Query-operand domains for date (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_date_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_date_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_date_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_date_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_date_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_date_eq IS 'EQL date query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_date_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_date_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_date_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_date_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_date_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_date_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_date_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_date_ord IS 'EQL date query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_date_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_date_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_date_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/double/double_eq_functions.sql b/packages/eql/src/v3/scalars/double/double_eq_functions.sql
index 49b33c2f6..597bb5b4e 100644
--- a/packages/eql/src/v3/scalars/double/double_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/double/double_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/double/double_eq_functions.sql
---! @brief Functions for public.eql_v3_double_eq.
+--! @brief Functions for public.{{prefix}}_double_eq.
 
---! @brief Index extractor for public.eql_v3_double_eq.
---! @param a public.eql_v3_double_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_double_eq.
+--! @param a public.{{prefix}}_double_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_double_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_eq.
---! @param a public.eql_v3_double_eq
---! @param b public.eql_v3_double_eq
+--! @brief Operator wrapper for public.{{prefix}}_double_eq.
+--! @param a public.{{prefix}}_double_eq
+--! @param b public.{{prefix}}_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_eq.
---! @param a public.eql_v3_double_eq
+--! @brief Operator wrapper for public.{{prefix}}_double_eq.
+--! @param a public.{{prefix}}_double_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_double_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_eq.
+--! @brief Operator wrapper for public.{{prefix}}_double_eq.
 --! @param a jsonb
---! @param b public.eql_v3_double_eq
+--! @param b public.{{prefix}}_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_double_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_eq.
---! @param a public.eql_v3_double_eq
---! @param b public.eql_v3_double_eq
+--! @brief Operator wrapper for public.{{prefix}}_double_eq.
+--! @param a public.{{prefix}}_double_eq
+--! @param b public.{{prefix}}_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_eq.
---! @param a public.eql_v3_double_eq
+--! @brief Operator wrapper for public.{{prefix}}_double_eq.
+--! @param a public.{{prefix}}_double_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_double_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_eq.
+--! @brief Operator wrapper for public.{{prefix}}_double_eq.
 --! @param a jsonb
---! @param b public.eql_v3_double_eq
+--! @param b public.{{prefix}}_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_double_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text)
-RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$
+--! @return public.{{prefix}}_double_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_eq, selector text)
+RETURNS public.{{prefix}}_double_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer)
-RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$
+--! @return public.{{prefix}}_double_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_eq, selector integer)
+RETURNS public.{{prefix}}_double_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_eq right operand of the blocked operator
---! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq)
-RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$
+--! @param selector public.{{prefix}}_double_eq right operand of the blocked operator
+--! @return public.{{prefix}}_double_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_eq)
+RETURNS public.{{prefix}}_double_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_double_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_double_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/double/double_eq_operators.sql b/packages/eql/src/v3/scalars/double/double_eq_operators.sql
index 46d0ae5e6..131bc0ab4 100644
--- a/packages/eql/src/v3/scalars/double/double_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/double/double_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/double/double_eq_functions.sql
 
 --! @file encrypted_domain/double/double_eq_operators.sql
---! @brief Operators for public.eql_v3_double_eq.
+--! @brief Operators for public.{{prefix}}_double_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq
 );
diff --git a/packages/eql/src/v3/scalars/double/double_functions.sql b/packages/eql/src/v3/scalars/double/double_functions.sql
index 80a425549..ea3964722 100644
--- a/packages/eql/src/v3/scalars/double/double_functions.sql
+++ b/packages/eql/src/v3/scalars/double/double_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/double/double_functions.sql
---! @brief Functions for public.eql_v3_double.
+--! @brief Functions for public.{{prefix}}_double.
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_double never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text)
-RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$
+--! @return public.{{prefix}}_double never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double, selector text)
+RETURNS public.{{prefix}}_double IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_double never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer)
-RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$
+--! @return public.{{prefix}}_double never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double, selector integer)
+RETURNS public.{{prefix}}_double IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double right operand of the blocked operator
---! @return public.eql_v3_double never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double)
-RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$
+--! @param selector public.{{prefix}}_double right operand of the blocked operator
+--! @return public.{{prefix}}_double never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double)
+RETURNS public.{{prefix}}_double IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double right operand of the blocked operator
+--! @param selector public.{{prefix}}_double right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double, b public.{{prefix}}_double)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double left operand of the blocked operator
+--! @param a public.{{prefix}}_double left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double right operand of the blocked operator
+--! @param b public.{{prefix}}_double right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/double/double_operators.sql b/packages/eql/src/v3/scalars/double/double_operators.sql
index 4e8da085a..84a00a710 100644
--- a/packages/eql/src/v3/scalars/double/double_operators.sql
+++ b/packages/eql/src/v3/scalars/double/double_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/double/double_functions.sql
 
 --! @file encrypted_domain/double/double_operators.sql
---! @brief Operators for public.eql_v3_double.
+--! @brief Operators for public.{{prefix}}_double.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_double, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double
 );
diff --git a/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql b/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql
index 3314ab536..d7b1b04cf 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_operators.sql
 
 --! @file encrypted_domain/double/double_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_double_ord.
+--! @brief Aggregates for public.{{prefix}}_double_ord.
 
---! @brief State function for min on public.eql_v3_double_ord.
---! @param state public.eql_v3_double_ord
---! @param value public.eql_v3_double_ord
---! @return public.eql_v3_double_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)
-RETURNS public.eql_v3_double_ord
+--! @brief State function for min on public.{{prefix}}_double_ord.
+--! @param state public.{{prefix}}_double_ord
+--! @param value public.{{prefix}}_double_ord
+--! @return public.{{prefix}}_double_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_double_ord, value public.{{prefix}}_double_ord)
+RETURNS public.{{prefix}}_double_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_double_ord.
---! @param input public.eql_v3_double_ord
---! @return public.eql_v3_double_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_double_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_double_ord.
+--! @param input public.{{prefix}}_double_ord
+--! @return public.{{prefix}}_double_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_double_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_double_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_double_ord.
---! @param state public.eql_v3_double_ord
---! @param value public.eql_v3_double_ord
---! @return public.eql_v3_double_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)
-RETURNS public.eql_v3_double_ord
+--! @brief State function for max on public.{{prefix}}_double_ord.
+--! @param state public.{{prefix}}_double_ord
+--! @param value public.{{prefix}}_double_ord
+--! @return public.{{prefix}}_double_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_double_ord, value public.{{prefix}}_double_ord)
+RETURNS public.{{prefix}}_double_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_double_ord.
---! @param input public.eql_v3_double_ord
---! @return public.eql_v3_double_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_double_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_double_ord.
+--! @param input public.{{prefix}}_double_ord
+--! @return public.{{prefix}}_double_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_double_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_double_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/double/double_ord_functions.sql b/packages/eql/src/v3/scalars/double/double_ord_functions.sql
index 2554ce56c..c599d065e 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/double/double_ord_functions.sql
---! @brief Functions for public.eql_v3_double_ord.
+--! @brief Functions for public.{{prefix}}_double_ord.
 
---! @brief Index extractor for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_double_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
---! @param a public.eql_v3_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
+--! @param a public.{{prefix}}_double_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector text)
-RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$
+--! @return public.{{prefix}}_double_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord, selector text)
+RETURNS public.{{prefix}}_double_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector integer)
-RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$
+--! @return public.{{prefix}}_double_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord, selector integer)
+RETURNS public.{{prefix}}_double_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_ord right operand of the blocked operator
---! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord)
-RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$
+--! @param selector public.{{prefix}}_double_ord right operand of the blocked operator
+--! @return public.{{prefix}}_double_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_ord)
+RETURNS public.{{prefix}}_double_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql
index c9d8fddb5..8be554877 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_ope_operators.sql
 
 --! @file encrypted_domain/double/double_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_double_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_double_ord_ope.
 
---! @brief State function for min on public.eql_v3_double_ord_ope.
---! @param state public.eql_v3_double_ord_ope
---! @param value public.eql_v3_double_ord_ope
---! @return public.eql_v3_double_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)
-RETURNS public.eql_v3_double_ord_ope
+--! @brief State function for min on public.{{prefix}}_double_ord_ope.
+--! @param state public.{{prefix}}_double_ord_ope
+--! @param value public.{{prefix}}_double_ord_ope
+--! @return public.{{prefix}}_double_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_double_ord_ope, value public.{{prefix}}_double_ord_ope)
+RETURNS public.{{prefix}}_double_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_double_ord_ope.
---! @param input public.eql_v3_double_ord_ope
---! @return public.eql_v3_double_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_double_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_double_ord_ope.
+--! @param input public.{{prefix}}_double_ord_ope
+--! @return public.{{prefix}}_double_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_double_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_double_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_double_ord_ope.
---! @param state public.eql_v3_double_ord_ope
---! @param value public.eql_v3_double_ord_ope
---! @return public.eql_v3_double_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)
-RETURNS public.eql_v3_double_ord_ope
+--! @brief State function for max on public.{{prefix}}_double_ord_ope.
+--! @param state public.{{prefix}}_double_ord_ope
+--! @param value public.{{prefix}}_double_ord_ope
+--! @return public.{{prefix}}_double_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_double_ord_ope, value public.{{prefix}}_double_ord_ope)
+RETURNS public.{{prefix}}_double_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_double_ord_ope.
---! @param input public.eql_v3_double_ord_ope
---! @return public.eql_v3_double_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_double_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_double_ord_ope.
+--! @param input public.{{prefix}}_double_ord_ope
+--! @return public.{{prefix}}_double_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_double_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_double_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql b/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql
index b3862e5e4..62ae689f7 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/double/double_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_double_ord_ope.
+--! @brief Functions for public.{{prefix}}_double_ord_ope.
 
---! @brief Index extractor for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_double_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector text)
-RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$
+--! @return public.{{prefix}}_double_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ope, selector text)
+RETURNS public.{{prefix}}_double_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector integer)
-RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$
+--! @return public.{{prefix}}_double_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ope, selector integer)
+RETURNS public.{{prefix}}_double_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator
---! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ope)
-RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_double_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_double_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_ord_ope)
+RETURNS public.{{prefix}}_double_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql b/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql
index e62acca0e..98a5eb75a 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_ope_functions.sql
 
 --! @file encrypted_domain/double/double_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_double_ord_ope.
+--! @brief Operators for public.{{prefix}}_double_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/double/double_ord_operators.sql b/packages/eql/src/v3/scalars/double/double_ord_operators.sql
index 6178c72f9..c12695ffc 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_functions.sql
 
 --! @file encrypted_domain/double/double_ord_operators.sql
---! @brief Operators for public.eql_v3_double_ord.
+--! @brief Operators for public.{{prefix}}_double_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord
 );
diff --git a/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql
index 19c60c2fd..cdf731006 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_ore_operators.sql
 
 --! @file encrypted_domain/double/double_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_double_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_double_ord_ore.
 
---! @brief State function for min on public.eql_v3_double_ord_ore.
---! @param state public.eql_v3_double_ord_ore
---! @param value public.eql_v3_double_ord_ore
---! @return public.eql_v3_double_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)
-RETURNS public.eql_v3_double_ord_ore
+--! @brief State function for min on public.{{prefix}}_double_ord_ore.
+--! @param state public.{{prefix}}_double_ord_ore
+--! @param value public.{{prefix}}_double_ord_ore
+--! @return public.{{prefix}}_double_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_double_ord_ore, value public.{{prefix}}_double_ord_ore)
+RETURNS public.{{prefix}}_double_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_double_ord_ore.
---! @param input public.eql_v3_double_ord_ore
---! @return public.eql_v3_double_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_double_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_double_ord_ore.
+--! @param input public.{{prefix}}_double_ord_ore
+--! @return public.{{prefix}}_double_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_double_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_double_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_double_ord_ore.
---! @param state public.eql_v3_double_ord_ore
---! @param value public.eql_v3_double_ord_ore
---! @return public.eql_v3_double_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)
-RETURNS public.eql_v3_double_ord_ore
+--! @brief State function for max on public.{{prefix}}_double_ord_ore.
+--! @param state public.{{prefix}}_double_ord_ore
+--! @param value public.{{prefix}}_double_ord_ore
+--! @return public.{{prefix}}_double_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_double_ord_ore, value public.{{prefix}}_double_ord_ore)
+RETURNS public.{{prefix}}_double_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_double_ord_ore.
---! @param input public.eql_v3_double_ord_ore
---! @return public.eql_v3_double_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_double_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_double_ord_ore.
+--! @param input public.{{prefix}}_double_ord_ore
+--! @return public.{{prefix}}_double_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_double_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_double_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql b/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql
index 9c65feb22..8cdec0b7f 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/double/double_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_double_ord_ore.
+--! @brief Functions for public.{{prefix}}_double_ord_ore.
 
---! @brief Index extractor for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_double_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_double_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text)
-RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$
+--! @return public.{{prefix}}_double_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ore, selector text)
+RETURNS public.{{prefix}}_double_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer)
-RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$
+--! @return public.{{prefix}}_double_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ore, selector integer)
+RETURNS public.{{prefix}}_double_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator
---! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore)
-RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_double_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_double_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_ord_ore)
+RETURNS public.{{prefix}}_double_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql b/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql
index 6057dbbe7..7928b366f 100644
--- a/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_ore_functions.sql
 
 --! @file encrypted_domain/double/double_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_double_ord_ore.
+--! @brief Operators for public.{{prefix}}_double_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/double/double_types.sql b/packages/eql/src/v3/scalars/double/double_types.sql
index b76cf46b4..95c4c3d85 100644
--- a/packages/eql/src/v3/scalars/double/double_types.sql
+++ b/packages/eql/src/v3/scalars/double/double_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_double.
+  --! @brief Encrypted domain public.{{prefix}}_double.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_double' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_double AS jsonb
+    CREATE DOMAIN public.{{prefix}}_double AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_double IS 'EQL encrypted double (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_double_eq.
+  --! @brief Encrypted domain public.{{prefix}}_double_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_double_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_double_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_double_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_double_eq IS 'EQL encrypted double (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_double_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_double_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_double_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_double_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_double_ord_ore IS 'EQL encrypted double (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_double_ord.
+  --! @brief Encrypted domain public.{{prefix}}_double_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_double_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_double_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_double_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_double_ord IS 'EQL encrypted double (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_double_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_double_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_double_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_double_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_double_ord_ope IS 'EQL encrypted double (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql b/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql
index 14d8b0d1d..ef2171dd9 100644
--- a/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql
+++ b/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql
@@ -7,244 +7,244 @@
 -- REQUIRE: src/v3/scalars/double/query_double_ord_ope_functions.sql
 
 --! @file encrypted_domain/double/json_entry_double_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_double_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_double_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_double_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_double_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_double_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_double_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_double_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_double_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_double_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_double_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_double_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_double_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_double_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_double_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql b/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql
index 8ff3727dc..391e2743e 100644
--- a/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql
+++ b/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql
@@ -5,140 +5,140 @@
 -- REQUIRE: src/v3/scalars/double/json_entry_double_functions.sql
 
 --! @file encrypted_domain/double/json_entry_double_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql b/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql
index 8c1c96076..814bf588e 100644
--- a/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/double/double_eq_functions.sql
 
 --! @file encrypted_domain/double/query_double_eq_functions.sql
---! @brief Functions for eql_v3.query_double_eq.
+--! @brief Functions for {{prefix}}.query_double_eq.
 
---! @brief Index extractor for eql_v3.query_double_eq.
---! @param a eql_v3.query_double_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_double_eq.
+--! @param a {{prefix}}.query_double_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_double_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_eq.
---! @param a public.eql_v3_double_eq
---! @param b eql_v3.query_double_eq
+--! @brief Operator wrapper for {{prefix}}.query_double_eq.
+--! @param a public.{{prefix}}_double_eq
+--! @param b {{prefix}}.query_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_eq, b {{prefix}}.query_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_eq.
---! @param a eql_v3.query_double_eq
---! @param b public.eql_v3_double_eq
+--! @brief Operator wrapper for {{prefix}}.query_double_eq.
+--! @param a {{prefix}}.query_double_eq
+--! @param b public.{{prefix}}_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_eq.
---! @param a public.eql_v3_double_eq
---! @param b eql_v3.query_double_eq
+--! @brief Operator wrapper for {{prefix}}.query_double_eq.
+--! @param a public.{{prefix}}_double_eq
+--! @param b {{prefix}}.query_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_eq, b {{prefix}}.query_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_eq.
---! @param a eql_v3.query_double_eq
---! @param b public.eql_v3_double_eq
+--! @brief Operator wrapper for {{prefix}}.query_double_eq.
+--! @param a {{prefix}}.query_double_eq
+--! @param b public.{{prefix}}_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_eq, b public.{{prefix}}_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql b/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql
index d7649b103..f6294d8d4 100644
--- a/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/double/query_double_eq_functions.sql
 
 --! @file encrypted_domain/double/query_double_eq_operators.sql
---! @brief Operators for eql_v3.query_double_eq.
+--! @brief Operators for {{prefix}}.query_double_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = {{prefix}}.query_double_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_double_eq, RIGHTARG = public.{{prefix}}_double_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = {{prefix}}.query_double_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_double_eq, RIGHTARG = public.{{prefix}}_double_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql b/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql
index ba4719765..de3f645c5 100644
--- a/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_functions.sql
 
 --! @file encrypted_domain/double/query_double_ord_functions.sql
---! @brief Functions for eql_v3.query_double_ord.
+--! @brief Functions for {{prefix}}.query_double_ord.
 
---! @brief Index extractor for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_double_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a public.eql_v3_double_ord
---! @param b eql_v3.query_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a public.{{prefix}}_double_ord
+--! @param b {{prefix}}.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord.
---! @param a eql_v3.query_double_ord
---! @param b public.eql_v3_double_ord
+--! @brief Operator wrapper for {{prefix}}.query_double_ord.
+--! @param a {{prefix}}.query_double_ord
+--! @param b public.{{prefix}}_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql
index a9d2f760e..dfa4f5908 100644
--- a/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_ope_functions.sql
 
 --! @file encrypted_domain/double/query_double_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_double_ord_ope.
+--! @brief Functions for {{prefix}}.query_double_ord_ope.
 
---! @brief Index extractor for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_double_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a public.eql_v3_double_ord_ope
---! @param b eql_v3.query_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a public.{{prefix}}_double_ord_ope
+--! @param b {{prefix}}.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ope.
---! @param a eql_v3.query_double_ord_ope
---! @param b public.eql_v3_double_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope.
+--! @param a {{prefix}}.query_double_ord_ope
+--! @param b public.{{prefix}}_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql
index 6976b9e3b..99f6594d2 100644
--- a/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/double/query_double_ord_ope_functions.sql
 
 --! @file encrypted_domain/double/query_double_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_double_ord_ope.
+--! @brief Operators for {{prefix}}.query_double_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql b/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql
index 4f7571aa3..fe4aa9e5e 100644
--- a/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/double/query_double_ord_functions.sql
 
 --! @file encrypted_domain/double/query_double_ord_operators.sql
---! @brief Operators for eql_v3.query_double_ord.
+--! @brief Operators for {{prefix}}.query_double_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql
index b916c2c40..e7e95f291 100644
--- a/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/double/double_ord_ore_functions.sql
 
 --! @file encrypted_domain/double/query_double_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_double_ord_ore.
+--! @brief Functions for {{prefix}}.query_double_ord_ore.
 
---! @brief Index extractor for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_double_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b eql_v3.query_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b {{prefix}}.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b eql_v3.query_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b {{prefix}}.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b eql_v3.query_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b {{prefix}}.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b eql_v3.query_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b {{prefix}}.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b eql_v3.query_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b {{prefix}}.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a public.eql_v3_double_ord_ore
---! @param b eql_v3.query_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a public.{{prefix}}_double_ord_ore
+--! @param b {{prefix}}.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_double_ord_ore.
---! @param a eql_v3.query_double_ord_ore
---! @param b public.eql_v3_double_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore.
+--! @param a {{prefix}}.query_double_ord_ore
+--! @param b public.{{prefix}}_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql
index 56ec45934..00a024cc5 100644
--- a/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/double/query_double_ord_ore_functions.sql
 
 --! @file encrypted_domain/double/query_double_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_double_ord_ore.
+--! @brief Operators for {{prefix}}.query_double_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/double/query_double_types.sql b/packages/eql/src/v3/scalars/double/query_double_types.sql
index 87362cdfc..9ab265bf5 100644
--- a/packages/eql/src/v3/scalars/double/query_double_types.sql
+++ b/packages/eql/src/v3/scalars/double/query_double_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/double/query_double_types.sql
 --! @brief Query-operand domains for double (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_double_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_double_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_double_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_double_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_double_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_double_eq IS 'EQL double query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_double_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_double_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_double_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_double_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_double_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_double_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_double_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_double_ord IS 'EQL double query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_double_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_double_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_double_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/functions.sql b/packages/eql/src/v3/scalars/functions.sql
index 3d6b7b3da..1376a4719 100644
--- a/packages/eql/src/v3/scalars/functions.sql
+++ b/packages/eql/src/v3/scalars/functions.sql
@@ -1,7 +1,7 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/scalars/functions.sql
---! @brief Shared blocker helper for the eql_v3 encrypted-domain families.
+--! @brief Shared blocker helper for the {{prefix}} encrypted-domain families.
 --!
 --! Per-domain wrapper functions live in src/v3/scalars/<T>/.
 --! Blockers in those files delegate to encrypted_domain_unsupported_bool
@@ -12,10 +12,10 @@
 --! @brief Shared blocker helper. Raises 'operator X is not supported
 --!        for TYPE' so unsupported domain operators surface a clear
 --!        error rather than fall through to native jsonb behaviour.
---! @param type_name Domain type name (eql_v3.<T>*)
+--! @param type_name Domain type name ({{prefix}}.<T>*)
 --! @param operator_name Operator symbol (=, <, @>, ->, etc.)
 --! @return boolean (never returns; always raises)
-CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)
+CREATE FUNCTION {{prefix}}_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)
 RETURNS boolean
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
@@ -30,10 +30,10 @@ $$ LANGUAGE plpgsql;
 --!        native operators whose result is jsonb (#>, -, #-, ||), so composed
 --!        expressions resolve and the body raises rather than failing earlier
 --!        with a misleading 'operator does not exist' on a boolean result.
---! @param type_name Domain type name (eql_v3.<T>*)
+--! @param type_name Domain type name ({{prefix}}.<T>*)
 --! @param operator_name Operator symbol (#>, -, #-, ||, etc.)
 --! @return jsonb (never returns; always raises)
-CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)
+CREATE FUNCTION {{prefix}}_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)
 RETURNS jsonb
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
@@ -46,10 +46,10 @@ $$ LANGUAGE plpgsql;
 --! @brief Shared blocker helper returning text. Identical to
 --!        encrypted_domain_unsupported_bool but typed for blockers shadowing
 --!        the native #>> operator whose result is text.
---! @param type_name Domain type name (eql_v3.<T>*)
+--! @param type_name Domain type name ({{prefix}}.<T>*)
 --! @param operator_name Operator symbol (#>>)
 --! @return text (never returns; always raises)
-CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)
+CREATE FUNCTION {{prefix}}_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)
 RETURNS text
 IMMUTABLE PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
diff --git a/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql b/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql
index 80e3e01d6..8247eb048 100644
--- a/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/integer/integer_eq_functions.sql
---! @brief Functions for public.eql_v3_integer_eq.
+--! @brief Functions for public.{{prefix}}_integer_eq.
 
---! @brief Index extractor for public.eql_v3_integer_eq.
---! @param a public.eql_v3_integer_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_integer_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_eq.
---! @param a public.eql_v3_integer_eq
---! @param b public.eql_v3_integer_eq
+--! @brief Operator wrapper for public.{{prefix}}_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
+--! @param b public.{{prefix}}_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_eq.
---! @param a public.eql_v3_integer_eq
+--! @brief Operator wrapper for public.{{prefix}}_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_integer_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_eq.
+--! @brief Operator wrapper for public.{{prefix}}_integer_eq.
 --! @param a jsonb
---! @param b public.eql_v3_integer_eq
+--! @param b public.{{prefix}}_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_integer_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_eq.
---! @param a public.eql_v3_integer_eq
---! @param b public.eql_v3_integer_eq
+--! @brief Operator wrapper for public.{{prefix}}_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
+--! @param b public.{{prefix}}_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_eq.
---! @param a public.eql_v3_integer_eq
+--! @brief Operator wrapper for public.{{prefix}}_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_integer_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_eq.
+--! @brief Operator wrapper for public.{{prefix}}_integer_eq.
 --! @param a jsonb
---! @param b public.eql_v3_integer_eq
+--! @param b public.{{prefix}}_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_integer_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text)
-RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$
+--! @return public.{{prefix}}_integer_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_eq, selector text)
+RETURNS public.{{prefix}}_integer_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer)
-RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$
+--! @return public.{{prefix}}_integer_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_eq, selector integer)
+RETURNS public.{{prefix}}_integer_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_eq right operand of the blocked operator
---! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq)
-RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$
+--! @param selector public.{{prefix}}_integer_eq right operand of the blocked operator
+--! @return public.{{prefix}}_integer_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_eq)
+RETURNS public.{{prefix}}_integer_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql b/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql
index 2848d6fe1..39a296bf6 100644
--- a/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/integer/integer_eq_functions.sql
 
 --! @file encrypted_domain/integer/integer_eq_operators.sql
---! @brief Operators for public.eql_v3_integer_eq.
+--! @brief Operators for public.{{prefix}}_integer_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_functions.sql b/packages/eql/src/v3/scalars/integer/integer_functions.sql
index c6fe4631d..560626ecb 100644
--- a/packages/eql/src/v3/scalars/integer/integer_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/integer/integer_functions.sql
---! @brief Functions for public.eql_v3_integer.
+--! @brief Functions for public.{{prefix}}_integer.
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_integer never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text)
-RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$
+--! @return public.{{prefix}}_integer never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer, selector text)
+RETURNS public.{{prefix}}_integer IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_integer never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer)
-RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$
+--! @return public.{{prefix}}_integer never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer, selector integer)
+RETURNS public.{{prefix}}_integer IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer right operand of the blocked operator
---! @return public.eql_v3_integer never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer)
-RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$
+--! @param selector public.{{prefix}}_integer right operand of the blocked operator
+--! @return public.{{prefix}}_integer never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer)
+RETURNS public.{{prefix}}_integer IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer right operand of the blocked operator
+--! @param selector public.{{prefix}}_integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer, b public.{{prefix}}_integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer left operand of the blocked operator
+--! @param a public.{{prefix}}_integer left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer right operand of the blocked operator
+--! @param b public.{{prefix}}_integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/integer/integer_operators.sql b/packages/eql/src/v3/scalars/integer/integer_operators.sql
index 476bbd5cf..14c37d131 100644
--- a/packages/eql/src/v3/scalars/integer/integer_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/integer/integer_functions.sql
 
 --! @file encrypted_domain/integer/integer_operators.sql
---! @brief Operators for public.eql_v3_integer.
+--! @brief Operators for public.{{prefix}}_integer.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql b/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql
index 2f7ead251..7be4947f8 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_operators.sql
 
 --! @file encrypted_domain/integer/integer_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_integer_ord.
+--! @brief Aggregates for public.{{prefix}}_integer_ord.
 
---! @brief State function for min on public.eql_v3_integer_ord.
---! @param state public.eql_v3_integer_ord
---! @param value public.eql_v3_integer_ord
---! @return public.eql_v3_integer_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)
-RETURNS public.eql_v3_integer_ord
+--! @brief State function for min on public.{{prefix}}_integer_ord.
+--! @param state public.{{prefix}}_integer_ord
+--! @param value public.{{prefix}}_integer_ord
+--! @return public.{{prefix}}_integer_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_integer_ord, value public.{{prefix}}_integer_ord)
+RETURNS public.{{prefix}}_integer_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_integer_ord.
---! @param input public.eql_v3_integer_ord
---! @return public.eql_v3_integer_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_integer_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_integer_ord.
+--! @param input public.{{prefix}}_integer_ord
+--! @return public.{{prefix}}_integer_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_integer_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_integer_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_integer_ord.
---! @param state public.eql_v3_integer_ord
---! @param value public.eql_v3_integer_ord
---! @return public.eql_v3_integer_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)
-RETURNS public.eql_v3_integer_ord
+--! @brief State function for max on public.{{prefix}}_integer_ord.
+--! @param state public.{{prefix}}_integer_ord
+--! @param value public.{{prefix}}_integer_ord
+--! @return public.{{prefix}}_integer_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_integer_ord, value public.{{prefix}}_integer_ord)
+RETURNS public.{{prefix}}_integer_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_integer_ord.
---! @param input public.eql_v3_integer_ord
---! @return public.eql_v3_integer_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_integer_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_integer_ord.
+--! @param input public.{{prefix}}_integer_ord
+--! @return public.{{prefix}}_integer_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_integer_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_integer_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql b/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql
index ae6de7ef8..b1ba2ddae 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/integer/integer_ord_functions.sql
---! @brief Functions for public.eql_v3_integer_ord.
+--! @brief Functions for public.{{prefix}}_integer_ord.
 
---! @brief Index extractor for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_integer_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
---! @param a public.eql_v3_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text)
-RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$
+--! @return public.{{prefix}}_integer_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord, selector text)
+RETURNS public.{{prefix}}_integer_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer)
-RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$
+--! @return public.{{prefix}}_integer_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord, selector integer)
+RETURNS public.{{prefix}}_integer_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_ord right operand of the blocked operator
---! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord)
-RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$
+--! @param selector public.{{prefix}}_integer_ord right operand of the blocked operator
+--! @return public.{{prefix}}_integer_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_ord)
+RETURNS public.{{prefix}}_integer_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql
index 7249ef061..059178bbd 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_operators.sql
 
 --! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_integer_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_integer_ord_ope.
 
---! @brief State function for min on public.eql_v3_integer_ord_ope.
---! @param state public.eql_v3_integer_ord_ope
---! @param value public.eql_v3_integer_ord_ope
---! @return public.eql_v3_integer_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)
-RETURNS public.eql_v3_integer_ord_ope
+--! @brief State function for min on public.{{prefix}}_integer_ord_ope.
+--! @param state public.{{prefix}}_integer_ord_ope
+--! @param value public.{{prefix}}_integer_ord_ope
+--! @return public.{{prefix}}_integer_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_integer_ord_ope, value public.{{prefix}}_integer_ord_ope)
+RETURNS public.{{prefix}}_integer_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_integer_ord_ope.
---! @param input public.eql_v3_integer_ord_ope
---! @return public.eql_v3_integer_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_integer_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_integer_ord_ope.
+--! @param input public.{{prefix}}_integer_ord_ope
+--! @return public.{{prefix}}_integer_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_integer_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_integer_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_integer_ord_ope.
---! @param state public.eql_v3_integer_ord_ope
---! @param value public.eql_v3_integer_ord_ope
---! @return public.eql_v3_integer_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)
-RETURNS public.eql_v3_integer_ord_ope
+--! @brief State function for max on public.{{prefix}}_integer_ord_ope.
+--! @param state public.{{prefix}}_integer_ord_ope
+--! @param value public.{{prefix}}_integer_ord_ope
+--! @return public.{{prefix}}_integer_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_integer_ord_ope, value public.{{prefix}}_integer_ord_ope)
+RETURNS public.{{prefix}}_integer_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_integer_ord_ope.
---! @param input public.eql_v3_integer_ord_ope
---! @return public.eql_v3_integer_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_integer_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_integer_ord_ope.
+--! @param input public.{{prefix}}_integer_ord_ope
+--! @return public.{{prefix}}_integer_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_integer_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_integer_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql
index 68d4b9e2a..dc9b5a81b 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/integer/integer_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_integer_ord_ope.
+--! @brief Functions for public.{{prefix}}_integer_ord_ope.
 
---! @brief Index extractor for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_integer_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text)
-RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$
+--! @return public.{{prefix}}_integer_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ope, selector text)
+RETURNS public.{{prefix}}_integer_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer)
-RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$
+--! @return public.{{prefix}}_integer_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ope, selector integer)
+RETURNS public.{{prefix}}_integer_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator
---! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope)
-RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_integer_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_integer_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_ord_ope)
+RETURNS public.{{prefix}}_integer_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql
index 8f8c319a8..7ff34c060 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_functions.sql
 
 --! @file encrypted_domain/integer/integer_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_integer_ord_ope.
+--! @brief Operators for public.{{prefix}}_integer_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql b/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql
index f5d9dcaa5..241961bb2 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_functions.sql
 
 --! @file encrypted_domain/integer/integer_ord_operators.sql
---! @brief Operators for public.eql_v3_integer_ord.
+--! @brief Operators for public.{{prefix}}_integer_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql
index d920423b0..e3a488d93 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_operators.sql
 
 --! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_integer_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_integer_ord_ore.
 
---! @brief State function for min on public.eql_v3_integer_ord_ore.
---! @param state public.eql_v3_integer_ord_ore
---! @param value public.eql_v3_integer_ord_ore
---! @return public.eql_v3_integer_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)
-RETURNS public.eql_v3_integer_ord_ore
+--! @brief State function for min on public.{{prefix}}_integer_ord_ore.
+--! @param state public.{{prefix}}_integer_ord_ore
+--! @param value public.{{prefix}}_integer_ord_ore
+--! @return public.{{prefix}}_integer_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_integer_ord_ore, value public.{{prefix}}_integer_ord_ore)
+RETURNS public.{{prefix}}_integer_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_integer_ord_ore.
---! @param input public.eql_v3_integer_ord_ore
---! @return public.eql_v3_integer_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_integer_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_integer_ord_ore.
+--! @param input public.{{prefix}}_integer_ord_ore
+--! @return public.{{prefix}}_integer_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_integer_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_integer_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_integer_ord_ore.
---! @param state public.eql_v3_integer_ord_ore
---! @param value public.eql_v3_integer_ord_ore
---! @return public.eql_v3_integer_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)
-RETURNS public.eql_v3_integer_ord_ore
+--! @brief State function for max on public.{{prefix}}_integer_ord_ore.
+--! @param state public.{{prefix}}_integer_ord_ore
+--! @param value public.{{prefix}}_integer_ord_ore
+--! @return public.{{prefix}}_integer_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_integer_ord_ore, value public.{{prefix}}_integer_ord_ore)
+RETURNS public.{{prefix}}_integer_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_integer_ord_ore.
---! @param input public.eql_v3_integer_ord_ore
---! @return public.eql_v3_integer_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_integer_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_integer_ord_ore.
+--! @param input public.{{prefix}}_integer_ord_ore
+--! @return public.{{prefix}}_integer_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_integer_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_integer_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql
index e4518aa9b..4bfd5d2eb 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/integer/integer_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_integer_ord_ore.
+--! @brief Functions for public.{{prefix}}_integer_ord_ore.
 
---! @brief Index extractor for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_integer_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_integer_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text)
-RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$
+--! @return public.{{prefix}}_integer_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ore, selector text)
+RETURNS public.{{prefix}}_integer_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer)
-RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$
+--! @return public.{{prefix}}_integer_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ore, selector integer)
+RETURNS public.{{prefix}}_integer_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator
---! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore)
-RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_integer_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_integer_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_ord_ore)
+RETURNS public.{{prefix}}_integer_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql
index ed50f6297..16126e76c 100644
--- a/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_functions.sql
 
 --! @file encrypted_domain/integer/integer_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_integer_ord_ore.
+--! @brief Operators for public.{{prefix}}_integer_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/integer/integer_types.sql b/packages/eql/src/v3/scalars/integer/integer_types.sql
index 94e791d99..b10c0ad7f 100644
--- a/packages/eql/src/v3/scalars/integer/integer_types.sql
+++ b/packages/eql/src/v3/scalars/integer/integer_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_integer.
+  --! @brief Encrypted domain public.{{prefix}}_integer.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_integer' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_integer AS jsonb
+    CREATE DOMAIN public.{{prefix}}_integer AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_integer IS 'EQL encrypted integer (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_integer_eq.
+  --! @brief Encrypted domain public.{{prefix}}_integer_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_integer_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_integer_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_integer_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_integer_eq IS 'EQL encrypted integer (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_integer_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_integer_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_integer_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_integer_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_integer_ord.
+  --! @brief Encrypted domain public.{{prefix}}_integer_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_integer_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_integer_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_integer_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_integer_ord IS 'EQL encrypted integer (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_integer_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_integer_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_integer_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_integer_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql b/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql
index f48c4e855..b46db4e60 100644
--- a/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql
@@ -7,244 +7,244 @@
 -- REQUIRE: src/v3/scalars/integer/query_integer_ord_ope_functions.sql
 
 --! @file encrypted_domain/integer/json_entry_integer_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_integer_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_integer_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_integer_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_integer_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_integer_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_integer_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_integer_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_integer_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_integer_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_integer_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql b/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql
index a8b63c55b..f58a9ca2c 100644
--- a/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql
@@ -5,140 +5,140 @@
 -- REQUIRE: src/v3/scalars/integer/json_entry_integer_functions.sql
 
 --! @file encrypted_domain/integer/json_entry_integer_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql
index de478f5a7..003be0b36 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/integer/integer_eq_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_eq_functions.sql
---! @brief Functions for eql_v3.query_integer_eq.
+--! @brief Functions for {{prefix}}.query_integer_eq.
 
---! @brief Index extractor for eql_v3.query_integer_eq.
---! @param a eql_v3.query_integer_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_integer_eq.
+--! @param a {{prefix}}.query_integer_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_integer_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_eq.
---! @param a public.eql_v3_integer_eq
---! @param b eql_v3.query_integer_eq
+--! @brief Operator wrapper for {{prefix}}.query_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
+--! @param b {{prefix}}.query_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_eq, b {{prefix}}.query_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_eq.
---! @param a eql_v3.query_integer_eq
---! @param b public.eql_v3_integer_eq
+--! @brief Operator wrapper for {{prefix}}.query_integer_eq.
+--! @param a {{prefix}}.query_integer_eq
+--! @param b public.{{prefix}}_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_eq.
---! @param a public.eql_v3_integer_eq
---! @param b eql_v3.query_integer_eq
+--! @brief Operator wrapper for {{prefix}}.query_integer_eq.
+--! @param a public.{{prefix}}_integer_eq
+--! @param b {{prefix}}.query_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_eq, b {{prefix}}.query_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_eq.
---! @param a eql_v3.query_integer_eq
---! @param b public.eql_v3_integer_eq
+--! @brief Operator wrapper for {{prefix}}.query_integer_eq.
+--! @param a {{prefix}}.query_integer_eq
+--! @param b public.{{prefix}}_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_eq, b public.{{prefix}}_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql
index 527d5f7eb..70693b1e7 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/integer/query_integer_eq_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_eq_operators.sql
---! @brief Operators for eql_v3.query_integer_eq.
+--! @brief Operators for {{prefix}}.query_integer_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = {{prefix}}.query_integer_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = {{prefix}}.query_integer_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql
index c730a223a..ad0592020 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_ord_functions.sql
---! @brief Functions for eql_v3.query_integer_ord.
+--! @brief Functions for {{prefix}}.query_integer_ord.
 
---! @brief Index extractor for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_integer_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a public.eql_v3_integer_ord
---! @param b eql_v3.query_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a public.{{prefix}}_integer_ord
+--! @param b {{prefix}}.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord.
---! @param a eql_v3.query_integer_ord
---! @param b public.eql_v3_integer_ord
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord.
+--! @param a {{prefix}}.query_integer_ord
+--! @param b public.{{prefix}}_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql
index 3ee5f5ad9..6f643a649 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_integer_ord_ope.
+--! @brief Functions for {{prefix}}.query_integer_ord_ope.
 
---! @brief Index extractor for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_integer_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a public.eql_v3_integer_ord_ope
---! @param b eql_v3.query_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a public.{{prefix}}_integer_ord_ope
+--! @param b {{prefix}}.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
---! @param a eql_v3.query_integer_ord_ope
---! @param b public.eql_v3_integer_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope.
+--! @param a {{prefix}}.query_integer_ord_ope
+--! @param b public.{{prefix}}_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql
index 7936100c4..fb5505e1b 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/integer/query_integer_ord_ope_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_integer_ord_ope.
+--! @brief Operators for {{prefix}}.query_integer_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql
index df7da7cb5..786245e45 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/integer/query_integer_ord_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_ord_operators.sql
---! @brief Operators for eql_v3.query_integer_ord.
+--! @brief Operators for {{prefix}}.query_integer_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql
index c66973750..3578cfb1a 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_integer_ord_ore.
+--! @brief Functions for {{prefix}}.query_integer_ord_ore.
 
---! @brief Index extractor for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_integer_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b eql_v3.query_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b {{prefix}}.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b eql_v3.query_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b {{prefix}}.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b eql_v3.query_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b {{prefix}}.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b eql_v3.query_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b {{prefix}}.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b eql_v3.query_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b {{prefix}}.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a public.eql_v3_integer_ord_ore
---! @param b eql_v3.query_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a public.{{prefix}}_integer_ord_ore
+--! @param b {{prefix}}.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
---! @param a eql_v3.query_integer_ord_ore
---! @param b public.eql_v3_integer_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore.
+--! @param a {{prefix}}.query_integer_ord_ore
+--! @param b public.{{prefix}}_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql
index c1a6b6025..d897eac84 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/integer/query_integer_ord_ore_functions.sql
 
 --! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_integer_ord_ore.
+--! @brief Operators for {{prefix}}.query_integer_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/integer/query_integer_types.sql b/packages/eql/src/v3/scalars/integer/query_integer_types.sql
index 697581072..62eb3a3f1 100644
--- a/packages/eql/src/v3/scalars/integer/query_integer_types.sql
+++ b/packages/eql/src/v3/scalars/integer/query_integer_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/integer/query_integer_types.sql
 --! @brief Query-operand domains for integer (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_integer_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_integer_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_integer_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_integer_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_integer_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_integer_eq IS 'EQL integer query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_integer_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_integer_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_integer_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_integer_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_integer_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_integer_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_integer_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_integer_ord IS 'EQL integer query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_integer_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_integer_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_integer_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/json/json_functions.sql b/packages/eql/src/v3/scalars/json/json_functions.sql
index ad5ca52a7..ee6cf992f 100644
--- a/packages/eql/src/v3/scalars/json/json_functions.sql
+++ b/packages/eql/src/v3/scalars/json/json_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/json/json_functions.sql
---! @brief Functions for public.eql_v3_json.
+--! @brief Functions for public.{{prefix}}_json.
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_json never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text)
-RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$
+--! @return public.{{prefix}}_json never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_json, selector text)
+RETURNS public.{{prefix}}_json IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_json never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer)
-RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$
+--! @return public.{{prefix}}_json never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_json, selector integer)
+RETURNS public.{{prefix}}_json IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_json right operand of the blocked operator
---! @return public.eql_v3_json never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json)
-RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$
+--! @param selector public.{{prefix}}_json right operand of the blocked operator
+--! @return public.{{prefix}}_json never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_json)
+RETURNS public.{{prefix}}_json IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_json, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_json, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_json right operand of the blocked operator
+--! @param selector public.{{prefix}}_json right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_json)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_json, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_json, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_json, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_json, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_json, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_json)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_json, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_json, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_json, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_json, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_json, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_json, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_json, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_json, b public.{{prefix}}_json)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json left operand of the blocked operator
+--! @param a public.{{prefix}}_json left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_json, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_json right operand of the blocked operator
+--! @param b public.{{prefix}}_json right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_json)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_json'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/json/json_operators.sql b/packages/eql/src/v3/scalars/json/json_operators.sql
index 21cdfd15b..e3937f294 100644
--- a/packages/eql/src/v3/scalars/json/json_operators.sql
+++ b/packages/eql/src/v3/scalars/json/json_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/json/json_functions.sql
 
 --! @file encrypted_domain/json/json_operators.sql
---! @brief Operators for public.eql_v3_json.
+--! @brief Operators for public.{{prefix}}_json.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_json, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_json, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_json, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_json, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json
 );
diff --git a/packages/eql/src/v3/scalars/json/json_types.sql b/packages/eql/src/v3/scalars/json/json_types.sql
index bebe5d0b6..047dc2091 100644
--- a/packages/eql/src/v3/scalars/json/json_types.sql
+++ b/packages/eql/src/v3/scalars/json/json_types.sql
@@ -6,21 +6,21 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_json.
+  --! @brief Encrypted domain public.{{prefix}}_json.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_json' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_json AS jsonb
+    CREATE DOMAIN public.{{prefix}}_json AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_json IS 'EQL encrypted json (storage only)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql
index fd20146ea..4d32069a1 100644
--- a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql
@@ -7,244 +7,244 @@
 -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
 
 --! @file encrypted_domain/numeric/json_entry_numeric_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_numeric_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_numeric_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_numeric_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_numeric_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_numeric_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_numeric_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_numeric_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_numeric_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql
index 2f204e242..49aad090b 100644
--- a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql
@@ -5,140 +5,140 @@
 -- REQUIRE: src/v3/scalars/numeric/json_entry_numeric_functions.sql
 
 --! @file encrypted_domain/numeric/json_entry_numeric_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql
index fe3ebd54f..a69b33759 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/numeric/numeric_eq_functions.sql
---! @brief Functions for public.eql_v3_numeric_eq.
+--! @brief Functions for public.{{prefix}}_numeric_eq.
 
---! @brief Index extractor for public.eql_v3_numeric_eq.
---! @param a public.eql_v3_numeric_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_numeric_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_eq.
---! @param a public.eql_v3_numeric_eq
---! @param b public.eql_v3_numeric_eq
+--! @brief Operator wrapper for public.{{prefix}}_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
+--! @param b public.{{prefix}}_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_eq.
---! @param a public.eql_v3_numeric_eq
+--! @brief Operator wrapper for public.{{prefix}}_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_numeric_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_eq.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_eq.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_eq
+--! @param b public.{{prefix}}_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_numeric_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_eq.
---! @param a public.eql_v3_numeric_eq
---! @param b public.eql_v3_numeric_eq
+--! @brief Operator wrapper for public.{{prefix}}_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
+--! @param b public.{{prefix}}_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_eq.
---! @param a public.eql_v3_numeric_eq
+--! @brief Operator wrapper for public.{{prefix}}_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_numeric_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_eq.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_eq.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_eq
+--! @param b public.{{prefix}}_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_numeric_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector text)
-RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$
+--! @return public.{{prefix}}_numeric_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_eq, selector text)
+RETURNS public.{{prefix}}_numeric_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector integer)
-RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$
+--! @return public.{{prefix}}_numeric_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_eq, selector integer)
+RETURNS public.{{prefix}}_numeric_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_eq right operand of the blocked operator
---! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_eq)
-RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$
+--! @param selector public.{{prefix}}_numeric_eq right operand of the blocked operator
+--! @return public.{{prefix}}_numeric_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_eq)
+RETURNS public.{{prefix}}_numeric_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql
index 1b9a16b7c..b606cae88 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_eq_functions.sql
 
 --! @file encrypted_domain/numeric/numeric_eq_operators.sql
---! @brief Operators for public.eql_v3_numeric_eq.
+--! @brief Operators for public.{{prefix}}_numeric_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_functions.sql
index 82001f519..7b591444a 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/numeric/numeric_functions.sql
---! @brief Functions for public.eql_v3_numeric.
+--! @brief Functions for public.{{prefix}}_numeric.
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_numeric never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text)
-RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$
+--! @return public.{{prefix}}_numeric never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric, selector text)
+RETURNS public.{{prefix}}_numeric IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_numeric never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer)
-RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$
+--! @return public.{{prefix}}_numeric never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric, selector integer)
+RETURNS public.{{prefix}}_numeric IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric right operand of the blocked operator
---! @return public.eql_v3_numeric never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric)
-RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$
+--! @param selector public.{{prefix}}_numeric right operand of the blocked operator
+--! @return public.{{prefix}}_numeric never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric)
+RETURNS public.{{prefix}}_numeric IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric right operand of the blocked operator
+--! @param selector public.{{prefix}}_numeric right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_operators.sql
index 9beeedd2b..fe88b6086 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_functions.sql
 
 --! @file encrypted_domain/numeric/numeric_operators.sql
---! @brief Operators for public.eql_v3_numeric.
+--! @brief Operators for public.{{prefix}}_numeric.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql
index 428a5cc00..2d76d14ed 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_operators.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_numeric_ord.
+--! @brief Aggregates for public.{{prefix}}_numeric_ord.
 
---! @brief State function for min on public.eql_v3_numeric_ord.
---! @param state public.eql_v3_numeric_ord
---! @param value public.eql_v3_numeric_ord
---! @return public.eql_v3_numeric_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)
-RETURNS public.eql_v3_numeric_ord
+--! @brief State function for min on public.{{prefix}}_numeric_ord.
+--! @param state public.{{prefix}}_numeric_ord
+--! @param value public.{{prefix}}_numeric_ord
+--! @return public.{{prefix}}_numeric_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_numeric_ord, value public.{{prefix}}_numeric_ord)
+RETURNS public.{{prefix}}_numeric_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_numeric_ord.
---! @param input public.eql_v3_numeric_ord
---! @return public.eql_v3_numeric_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_numeric_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_numeric_ord.
+--! @param input public.{{prefix}}_numeric_ord
+--! @return public.{{prefix}}_numeric_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_numeric_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_numeric_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_numeric_ord.
---! @param state public.eql_v3_numeric_ord
---! @param value public.eql_v3_numeric_ord
---! @return public.eql_v3_numeric_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)
-RETURNS public.eql_v3_numeric_ord
+--! @brief State function for max on public.{{prefix}}_numeric_ord.
+--! @param state public.{{prefix}}_numeric_ord
+--! @param value public.{{prefix}}_numeric_ord
+--! @return public.{{prefix}}_numeric_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_numeric_ord, value public.{{prefix}}_numeric_ord)
+RETURNS public.{{prefix}}_numeric_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_numeric_ord.
---! @param input public.eql_v3_numeric_ord
---! @return public.eql_v3_numeric_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_numeric_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_numeric_ord.
+--! @param input public.{{prefix}}_numeric_ord
+--! @return public.{{prefix}}_numeric_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_numeric_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_numeric_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql
index bd7d97471..079c1be40 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_functions.sql
---! @brief Functions for public.eql_v3_numeric_ord.
+--! @brief Functions for public.{{prefix}}_numeric_ord.
 
---! @brief Index extractor for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_numeric_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
---! @param a public.eql_v3_numeric_ord
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text)
-RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$
+--! @return public.{{prefix}}_numeric_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord, selector text)
+RETURNS public.{{prefix}}_numeric_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer)
-RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$
+--! @return public.{{prefix}}_numeric_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord, selector integer)
+RETURNS public.{{prefix}}_numeric_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_ord right operand of the blocked operator
---! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord)
-RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$
+--! @param selector public.{{prefix}}_numeric_ord right operand of the blocked operator
+--! @return public.{{prefix}}_numeric_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_ord)
+RETURNS public.{{prefix}}_numeric_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql
index 4190c25d9..f0627aafc 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_operators.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_numeric_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_numeric_ord_ope.
 
---! @brief State function for min on public.eql_v3_numeric_ord_ope.
---! @param state public.eql_v3_numeric_ord_ope
---! @param value public.eql_v3_numeric_ord_ope
---! @return public.eql_v3_numeric_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)
-RETURNS public.eql_v3_numeric_ord_ope
+--! @brief State function for min on public.{{prefix}}_numeric_ord_ope.
+--! @param state public.{{prefix}}_numeric_ord_ope
+--! @param value public.{{prefix}}_numeric_ord_ope
+--! @return public.{{prefix}}_numeric_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_numeric_ord_ope, value public.{{prefix}}_numeric_ord_ope)
+RETURNS public.{{prefix}}_numeric_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_numeric_ord_ope.
---! @param input public.eql_v3_numeric_ord_ope
---! @return public.eql_v3_numeric_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_numeric_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_numeric_ord_ope.
+--! @param input public.{{prefix}}_numeric_ord_ope
+--! @return public.{{prefix}}_numeric_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_numeric_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_numeric_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_numeric_ord_ope.
---! @param state public.eql_v3_numeric_ord_ope
---! @param value public.eql_v3_numeric_ord_ope
---! @return public.eql_v3_numeric_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)
-RETURNS public.eql_v3_numeric_ord_ope
+--! @brief State function for max on public.{{prefix}}_numeric_ord_ope.
+--! @param state public.{{prefix}}_numeric_ord_ope
+--! @param value public.{{prefix}}_numeric_ord_ope
+--! @return public.{{prefix}}_numeric_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_numeric_ord_ope, value public.{{prefix}}_numeric_ord_ope)
+RETURNS public.{{prefix}}_numeric_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_numeric_ord_ope.
---! @param input public.eql_v3_numeric_ord_ope
---! @return public.eql_v3_numeric_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_numeric_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_numeric_ord_ope.
+--! @param input public.{{prefix}}_numeric_ord_ope
+--! @return public.{{prefix}}_numeric_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_numeric_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_numeric_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql
index 5f2f4ec32..4ca0974f4 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_numeric_ord_ope.
+--! @brief Functions for public.{{prefix}}_numeric_ord_ope.
 
---! @brief Index extractor for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_numeric_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text)
-RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$
+--! @return public.{{prefix}}_numeric_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ope, selector text)
+RETURNS public.{{prefix}}_numeric_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer)
-RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$
+--! @return public.{{prefix}}_numeric_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ope, selector integer)
+RETURNS public.{{prefix}}_numeric_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator
---! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope)
-RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_numeric_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_ord_ope)
+RETURNS public.{{prefix}}_numeric_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql
index 26f446e46..ab374cb5f 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_functions.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_numeric_ord_ope.
+--! @brief Operators for public.{{prefix}}_numeric_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql
index c3f29d217..7fb87b0c1 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_functions.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_operators.sql
---! @brief Operators for public.eql_v3_numeric_ord.
+--! @brief Operators for public.{{prefix}}_numeric_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql
index 83f2c2f2a..76db0474c 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_operators.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_numeric_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_numeric_ord_ore.
 
---! @brief State function for min on public.eql_v3_numeric_ord_ore.
---! @param state public.eql_v3_numeric_ord_ore
---! @param value public.eql_v3_numeric_ord_ore
---! @return public.eql_v3_numeric_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)
-RETURNS public.eql_v3_numeric_ord_ore
+--! @brief State function for min on public.{{prefix}}_numeric_ord_ore.
+--! @param state public.{{prefix}}_numeric_ord_ore
+--! @param value public.{{prefix}}_numeric_ord_ore
+--! @return public.{{prefix}}_numeric_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_numeric_ord_ore, value public.{{prefix}}_numeric_ord_ore)
+RETURNS public.{{prefix}}_numeric_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_numeric_ord_ore.
---! @param input public.eql_v3_numeric_ord_ore
---! @return public.eql_v3_numeric_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_numeric_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_numeric_ord_ore.
+--! @param input public.{{prefix}}_numeric_ord_ore
+--! @return public.{{prefix}}_numeric_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_numeric_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_numeric_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_numeric_ord_ore.
---! @param state public.eql_v3_numeric_ord_ore
---! @param value public.eql_v3_numeric_ord_ore
---! @return public.eql_v3_numeric_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)
-RETURNS public.eql_v3_numeric_ord_ore
+--! @brief State function for max on public.{{prefix}}_numeric_ord_ore.
+--! @param state public.{{prefix}}_numeric_ord_ore
+--! @param value public.{{prefix}}_numeric_ord_ore
+--! @return public.{{prefix}}_numeric_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_numeric_ord_ore, value public.{{prefix}}_numeric_ord_ore)
+RETURNS public.{{prefix}}_numeric_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_numeric_ord_ore.
---! @param input public.eql_v3_numeric_ord_ore
---! @return public.eql_v3_numeric_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_numeric_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_numeric_ord_ore.
+--! @param input public.{{prefix}}_numeric_ord_ore
+--! @return public.{{prefix}}_numeric_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_numeric_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_numeric_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql
index 5481863bc..748793ea5 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_numeric_ord_ore.
+--! @brief Functions for public.{{prefix}}_numeric_ord_ore.
 
---! @brief Index extractor for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_numeric_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text)
-RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$
+--! @return public.{{prefix}}_numeric_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ore, selector text)
+RETURNS public.{{prefix}}_numeric_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer)
-RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$
+--! @return public.{{prefix}}_numeric_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ore, selector integer)
+RETURNS public.{{prefix}}_numeric_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator
---! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore)
-RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_numeric_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_ord_ore)
+RETURNS public.{{prefix}}_numeric_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql
index ed2e72be8..c017dd604 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_functions.sql
 
 --! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_numeric_ord_ore.
+--! @brief Operators for public.{{prefix}}_numeric_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/numeric/numeric_types.sql b/packages/eql/src/v3/scalars/numeric/numeric_types.sql
index 3ee6c9627..37852ac11 100644
--- a/packages/eql/src/v3/scalars/numeric/numeric_types.sql
+++ b/packages/eql/src/v3/scalars/numeric/numeric_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_numeric.
+  --! @brief Encrypted domain public.{{prefix}}_numeric.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_numeric' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_numeric AS jsonb
+    CREATE DOMAIN public.{{prefix}}_numeric AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_numeric IS 'EQL encrypted numeric (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_numeric_eq.
+  --! @brief Encrypted domain public.{{prefix}}_numeric_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_numeric_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_numeric_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_numeric_eq IS 'EQL encrypted numeric (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_numeric_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_numeric_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_numeric_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_numeric_ord.
+  --! @brief Encrypted domain public.{{prefix}}_numeric_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_numeric_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_numeric_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_numeric_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_numeric_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_numeric_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql
index 7286732dc..b250bac08 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_eq_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_eq_functions.sql
---! @brief Functions for eql_v3.query_numeric_eq.
+--! @brief Functions for {{prefix}}.query_numeric_eq.
 
---! @brief Index extractor for eql_v3.query_numeric_eq.
---! @param a eql_v3.query_numeric_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_numeric_eq.
+--! @param a {{prefix}}.query_numeric_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_numeric_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_eq.
---! @param a public.eql_v3_numeric_eq
---! @param b eql_v3.query_numeric_eq
+--! @brief Operator wrapper for {{prefix}}.query_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
+--! @param b {{prefix}}.query_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_eq, b {{prefix}}.query_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_eq.
---! @param a eql_v3.query_numeric_eq
---! @param b public.eql_v3_numeric_eq
+--! @brief Operator wrapper for {{prefix}}.query_numeric_eq.
+--! @param a {{prefix}}.query_numeric_eq
+--! @param b public.{{prefix}}_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_eq.
---! @param a public.eql_v3_numeric_eq
---! @param b eql_v3.query_numeric_eq
+--! @brief Operator wrapper for {{prefix}}.query_numeric_eq.
+--! @param a public.{{prefix}}_numeric_eq
+--! @param b {{prefix}}.query_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_eq, b {{prefix}}.query_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_eq.
---! @param a eql_v3.query_numeric_eq
---! @param b public.eql_v3_numeric_eq
+--! @brief Operator wrapper for {{prefix}}.query_numeric_eq.
+--! @param a {{prefix}}.query_numeric_eq
+--! @param b public.{{prefix}}_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_eq, b public.{{prefix}}_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql
index 046b26a63..78ad85f81 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/numeric/query_numeric_eq_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_eq_operators.sql
---! @brief Operators for eql_v3.query_numeric_eq.
+--! @brief Operators for {{prefix}}.query_numeric_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = {{prefix}}.query_numeric_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = {{prefix}}.query_numeric_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql
index 104bd7125..08cfcf2fc 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_ord_functions.sql
---! @brief Functions for eql_v3.query_numeric_ord.
+--! @brief Functions for {{prefix}}.query_numeric_ord.
 
---! @brief Index extractor for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_numeric_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a public.eql_v3_numeric_ord
---! @param b eql_v3.query_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a public.{{prefix}}_numeric_ord
+--! @param b {{prefix}}.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord.
---! @param a eql_v3.query_numeric_ord
---! @param b public.eql_v3_numeric_ord
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord.
+--! @param a {{prefix}}.query_numeric_ord
+--! @param b public.{{prefix}}_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
index 41f326c5a..cafc3daa9 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_numeric_ord_ope.
+--! @brief Functions for {{prefix}}.query_numeric_ord_ope.
 
---! @brief Index extractor for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_numeric_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a public.eql_v3_numeric_ord_ope
---! @param b eql_v3.query_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a public.{{prefix}}_numeric_ord_ope
+--! @param b {{prefix}}.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
---! @param a eql_v3.query_numeric_ord_ope
---! @param b public.eql_v3_numeric_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope.
+--! @param a {{prefix}}.query_numeric_ord_ope
+--! @param b public.{{prefix}}_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql
index fa3d91bd1..2a16ae3af 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_numeric_ord_ope.
+--! @brief Operators for {{prefix}}.query_numeric_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql
index e88a4aa28..88ba9557e 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_ord_operators.sql
---! @brief Operators for eql_v3.query_numeric_ord.
+--! @brief Operators for {{prefix}}.query_numeric_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
index 7b0b3b19b..092a57f9c 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_numeric_ord_ore.
+--! @brief Functions for {{prefix}}.query_numeric_ord_ore.
 
---! @brief Index extractor for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_numeric_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b eql_v3.query_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b {{prefix}}.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b eql_v3.query_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b {{prefix}}.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b eql_v3.query_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b {{prefix}}.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b eql_v3.query_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b {{prefix}}.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b eql_v3.query_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b {{prefix}}.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a public.eql_v3_numeric_ord_ore
---! @param b eql_v3.query_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a public.{{prefix}}_numeric_ord_ore
+--! @param b {{prefix}}.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
---! @param a eql_v3.query_numeric_ord_ore
---! @param b public.eql_v3_numeric_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore.
+--! @param a {{prefix}}.query_numeric_ord_ore
+--! @param b public.{{prefix}}_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql
index 0147b7351..b9d1959cc 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
 
 --! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_numeric_ord_ore.
+--! @brief Operators for {{prefix}}.query_numeric_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql
index 96c9aa9b4..b9646bcf8 100644
--- a/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql
+++ b/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/numeric/query_numeric_types.sql
 --! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_numeric_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_numeric_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_numeric_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_numeric_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_numeric_eq IS 'EQL numeric query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_numeric_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_numeric_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_numeric_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_numeric_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_numeric_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_numeric_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_numeric_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_numeric_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_numeric_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/ore_fallback.sql b/packages/eql/src/v3/scalars/ore_fallback.sql
index 993af2e32..ce56a258a 100644
--- a/packages/eql/src/v3/scalars/ore_fallback.sql
+++ b/packages/eql/src/v3/scalars/ore_fallback.sql
@@ -25,14 +25,14 @@
 --!
 --! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,
 --! which ATTEMPTS to create the default btree operator class for
---! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege
+--! {{prefix}}_internal.ore_block_256 and skips it on insufficient_privilege
 --! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud
 --! Supabase and most hosted Postgres — run the installer as a non-superuser
 --! role). When the class was created, this file is a no-op.
 --!
 --! When the class was skipped, the ORE-carrying domains would otherwise
 --! install half-working: `<`/`>` comparisons still run (as unindexable seq
---! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare
+--! scans), while `CREATE INDEX ... ({{prefix}}.ord_term(col))` and bare
 --! `ORDER BY` fail with opaque Postgres errors. Instead of that silent
 --! degradation, this file poisons every ORE-carrying domain (and its
 --! query-operand twin) with an always-raising CHECK constraint, so the first
@@ -62,7 +62,7 @@ BEGIN
     JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod
     WHERE am.amname = 'btree'
       AND c.opcdefault
-      AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype
+      AND c.opcintype = '{{prefix}}_internal.ore_block_256'::pg_catalog.regtype
   ) THEN
     RETURN;
   END IF;
@@ -70,7 +70,7 @@ BEGIN
   --! @brief Poison CHECK backing for the ORE-carrying domains on platforms
   --!        without the ORE operator class. Always raises; never returns.
   --! @internal
-  CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)
+  CREATE FUNCTION {{prefix}}_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)
   RETURNS boolean
   IMMUTABLE PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -87,65 +87,65 @@ BEGIN
   -- must not abort). Domain coercion still enforces the CHECK on every new
   -- cast/insert regardless of validation status.
 
-  ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_integer_ord_ore', 'public.{{prefix}}_integer_eq (equality) or public.{{prefix}}_integer_ord (ordering) or public.{{prefix}}_integer_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_integer_ord_ore', '{{prefix}}.query_integer_eq (equality) or {{prefix}}.query_integer_ord (ordering) or {{prefix}}.query_integer_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_smallint_ord_ore', 'public.{{prefix}}_smallint_eq (equality) or public.{{prefix}}_smallint_ord (ordering) or public.{{prefix}}_smallint_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_smallint_ord_ore', '{{prefix}}.query_smallint_eq (equality) or {{prefix}}.query_smallint_ord (ordering) or {{prefix}}.query_smallint_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_bigint_ord_ore', 'public.{{prefix}}_bigint_eq (equality) or public.{{prefix}}_bigint_ord (ordering) or public.{{prefix}}_bigint_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_bigint_ord_ore', '{{prefix}}.query_bigint_eq (equality) or {{prefix}}.query_bigint_ord (ordering) or {{prefix}}.query_bigint_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_date_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_date_ord_ore', 'public.{{prefix}}_date_eq (equality) or public.{{prefix}}_date_ord (ordering) or public.{{prefix}}_date_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_date_ord_ore', '{{prefix}}.query_date_eq (equality) or {{prefix}}.query_date_ord (ordering) or {{prefix}}.query_date_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_timestamp_ord_ore', 'public.{{prefix}}_timestamp_eq (equality) or public.{{prefix}}_timestamp_ord (ordering) or public.{{prefix}}_timestamp_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_timestamp_ord_ore', '{{prefix}}.query_timestamp_eq (equality) or {{prefix}}.query_timestamp_ord (ordering) or {{prefix}}.query_timestamp_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_numeric_ord_ore', 'public.{{prefix}}_numeric_eq (equality) or public.{{prefix}}_numeric_ord (ordering) or public.{{prefix}}_numeric_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_numeric_ord_ore', '{{prefix}}.query_numeric_eq (equality) or {{prefix}}.query_numeric_ord (ordering) or {{prefix}}.query_numeric_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_text_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_text_ord_ore', 'public.{{prefix}}_text_eq (equality) or public.{{prefix}}_text_match (match) or public.{{prefix}}_text_ord (ordering) or public.{{prefix}}_text_ord_ope (ordering) or public.{{prefix}}_text_search (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_text_ord_ore', '{{prefix}}.query_text_eq (equality) or {{prefix}}.query_text_match (match) or {{prefix}}.query_text_ord (ordering) or {{prefix}}.query_text_ord_ope (ordering) or {{prefix}}.query_text_search (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_text_search_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_text_search_ore', 'public.{{prefix}}_text_eq (equality) or public.{{prefix}}_text_match (match) or public.{{prefix}}_text_ord (ordering) or public.{{prefix}}_text_ord_ope (ordering) or public.{{prefix}}_text_search (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_text_search_ore', '{{prefix}}.query_text_eq (equality) or {{prefix}}.query_text_match (match) or {{prefix}}.query_text_ord (ordering) or {{prefix}}.query_text_ord_ope (ordering) or {{prefix}}.query_text_search (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_real_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_real_ord_ore', 'public.{{prefix}}_real_eq (equality) or public.{{prefix}}_real_ord (ordering) or public.{{prefix}}_real_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_real_ord_ore', '{{prefix}}.query_real_eq (equality) or {{prefix}}.query_real_ord (ordering) or {{prefix}}.query_real_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN public.{{prefix}}_double_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_double_ord_ore', 'public.{{prefix}}_double_eq (equality) or public.{{prefix}}_double_ord (ordering) or public.{{prefix}}_double_ord_ope (ordering)')) NOT VALID;
 
-  ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable
-    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;
+  ALTER DOMAIN {{prefix}}.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable
+    CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_double_ord_ore', '{{prefix}}.query_double_eq (equality) or {{prefix}}.query_double_ord (ordering) or {{prefix}}.query_double_ord_ope (ordering)')) NOT VALID;
 
   RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';
 END;
diff --git a/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql b/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql
index 2493cab90..6cab30901 100644
--- a/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql
+++ b/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql
@@ -7,244 +7,244 @@
 -- REQUIRE: src/v3/scalars/real/query_real_ord_ope_functions.sql
 
 --! @file encrypted_domain/real/json_entry_real_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_real_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_real_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_real_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_real_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_real_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_real_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_real_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_real_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_real_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_real_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_real_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_real_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql b/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql
index 2fcdc8691..4ddcc8522 100644
--- a/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql
+++ b/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql
@@ -5,140 +5,140 @@
 -- REQUIRE: src/v3/scalars/real/json_entry_real_functions.sql
 
 --! @file encrypted_domain/real/json_entry_real_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql b/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql
index cacb702cc..637bd5045 100644
--- a/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/real/real_eq_functions.sql
 
 --! @file encrypted_domain/real/query_real_eq_functions.sql
---! @brief Functions for eql_v3.query_real_eq.
+--! @brief Functions for {{prefix}}.query_real_eq.
 
---! @brief Index extractor for eql_v3.query_real_eq.
---! @param a eql_v3.query_real_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_real_eq.
+--! @param a {{prefix}}.query_real_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_real_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_eq.
---! @param a public.eql_v3_real_eq
---! @param b eql_v3.query_real_eq
+--! @brief Operator wrapper for {{prefix}}.query_real_eq.
+--! @param a public.{{prefix}}_real_eq
+--! @param b {{prefix}}.query_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_eq, b {{prefix}}.query_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_eq.
---! @param a eql_v3.query_real_eq
---! @param b public.eql_v3_real_eq
+--! @brief Operator wrapper for {{prefix}}.query_real_eq.
+--! @param a {{prefix}}.query_real_eq
+--! @param b public.{{prefix}}_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_eq.
---! @param a public.eql_v3_real_eq
---! @param b eql_v3.query_real_eq
+--! @brief Operator wrapper for {{prefix}}.query_real_eq.
+--! @param a public.{{prefix}}_real_eq
+--! @param b {{prefix}}.query_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_eq, b {{prefix}}.query_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_eq.
---! @param a eql_v3.query_real_eq
---! @param b public.eql_v3_real_eq
+--! @brief Operator wrapper for {{prefix}}.query_real_eq.
+--! @param a {{prefix}}.query_real_eq
+--! @param b public.{{prefix}}_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql b/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql
index 00ba0dfe6..340424f44 100644
--- a/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/real/query_real_eq_functions.sql
 
 --! @file encrypted_domain/real/query_real_eq_operators.sql
---! @brief Operators for eql_v3.query_real_eq.
+--! @brief Operators for {{prefix}}.query_real_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = {{prefix}}.query_real_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_real_eq, RIGHTARG = public.{{prefix}}_real_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = {{prefix}}.query_real_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_real_eq, RIGHTARG = public.{{prefix}}_real_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql b/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql
index 8ca85ec93..b1292e6e4 100644
--- a/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_functions.sql
 
 --! @file encrypted_domain/real/query_real_ord_functions.sql
---! @brief Functions for eql_v3.query_real_ord.
+--! @brief Functions for {{prefix}}.query_real_ord.
 
---! @brief Index extractor for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_real_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b eql_v3.query_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b {{prefix}}.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord.
---! @param a eql_v3.query_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for {{prefix}}.query_real_ord.
+--! @param a {{prefix}}.query_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql
index 4bc7d3b16..6e71401ea 100644
--- a/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_ope_functions.sql
 
 --! @file encrypted_domain/real/query_real_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_real_ord_ope.
+--! @brief Functions for {{prefix}}.query_real_ord_ope.
 
---! @brief Index extractor for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_real_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b eql_v3.query_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b {{prefix}}.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ope.
---! @param a eql_v3.query_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope.
+--! @param a {{prefix}}.query_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql
index de0c9606d..b8b13b85e 100644
--- a/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/real/query_real_ord_ope_functions.sql
 
 --! @file encrypted_domain/real/query_real_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_real_ord_ope.
+--! @brief Operators for {{prefix}}.query_real_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql b/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql
index 2859bc840..6ae884957 100644
--- a/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/real/query_real_ord_functions.sql
 
 --! @file encrypted_domain/real/query_real_ord_operators.sql
---! @brief Operators for eql_v3.query_real_ord.
+--! @brief Operators for {{prefix}}.query_real_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql
index 82aedde96..db512dd9a 100644
--- a/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_ore_functions.sql
 
 --! @file encrypted_domain/real/query_real_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_real_ord_ore.
+--! @brief Functions for {{prefix}}.query_real_ord_ore.
 
---! @brief Index extractor for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_real_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b eql_v3.query_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b {{prefix}}.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b eql_v3.query_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b {{prefix}}.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b eql_v3.query_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b {{prefix}}.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b eql_v3.query_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b {{prefix}}.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b eql_v3.query_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b {{prefix}}.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b eql_v3.query_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b {{prefix}}.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_real_ord_ore.
---! @param a eql_v3.query_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore.
+--! @param a {{prefix}}.query_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql
index c7d56e1dc..8e8d624d8 100644
--- a/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/real/query_real_ord_ore_functions.sql
 
 --! @file encrypted_domain/real/query_real_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_real_ord_ore.
+--! @brief Operators for {{prefix}}.query_real_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/real/query_real_types.sql b/packages/eql/src/v3/scalars/real/query_real_types.sql
index 57ed840bc..a7b81b073 100644
--- a/packages/eql/src/v3/scalars/real/query_real_types.sql
+++ b/packages/eql/src/v3/scalars/real/query_real_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/real/query_real_types.sql
 --! @brief Query-operand domains for real (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_real_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_real_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_real_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_real_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_real_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_real_eq IS 'EQL real query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_real_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_real_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_real_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_real_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_real_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_real_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_real_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_real_ord IS 'EQL real query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_real_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_real_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_real_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/real/real_eq_functions.sql b/packages/eql/src/v3/scalars/real/real_eq_functions.sql
index a7b504d59..382829281 100644
--- a/packages/eql/src/v3/scalars/real/real_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/real/real_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/real/real_eq_functions.sql
---! @brief Functions for public.eql_v3_real_eq.
+--! @brief Functions for public.{{prefix}}_real_eq.
 
---! @brief Index extractor for public.eql_v3_real_eq.
---! @param a public.eql_v3_real_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_real_eq.
+--! @param a public.{{prefix}}_real_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_real_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_eq.
---! @param a public.eql_v3_real_eq
---! @param b public.eql_v3_real_eq
+--! @brief Operator wrapper for public.{{prefix}}_real_eq.
+--! @param a public.{{prefix}}_real_eq
+--! @param b public.{{prefix}}_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_eq.
---! @param a public.eql_v3_real_eq
+--! @brief Operator wrapper for public.{{prefix}}_real_eq.
+--! @param a public.{{prefix}}_real_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_real_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_eq.
+--! @brief Operator wrapper for public.{{prefix}}_real_eq.
 --! @param a jsonb
---! @param b public.eql_v3_real_eq
+--! @param b public.{{prefix}}_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_real_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_eq.
---! @param a public.eql_v3_real_eq
---! @param b public.eql_v3_real_eq
+--! @brief Operator wrapper for public.{{prefix}}_real_eq.
+--! @param a public.{{prefix}}_real_eq
+--! @param b public.{{prefix}}_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_eq.
---! @param a public.eql_v3_real_eq
+--! @brief Operator wrapper for public.{{prefix}}_real_eq.
+--! @param a public.{{prefix}}_real_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_real_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_eq.
+--! @brief Operator wrapper for public.{{prefix}}_real_eq.
 --! @param a jsonb
---! @param b public.eql_v3_real_eq
+--! @param b public.{{prefix}}_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_real_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text)
-RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$
+--! @return public.{{prefix}}_real_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_eq, selector text)
+RETURNS public.{{prefix}}_real_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer)
-RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$
+--! @return public.{{prefix}}_real_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_eq, selector integer)
+RETURNS public.{{prefix}}_real_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_eq right operand of the blocked operator
---! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq)
-RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$
+--! @param selector public.{{prefix}}_real_eq right operand of the blocked operator
+--! @return public.{{prefix}}_real_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_eq)
+RETURNS public.{{prefix}}_real_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_real_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_real_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/real/real_eq_operators.sql b/packages/eql/src/v3/scalars/real/real_eq_operators.sql
index 9ddac1035..a5c06a230 100644
--- a/packages/eql/src/v3/scalars/real/real_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/real/real_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/real/real_eq_functions.sql
 
 --! @file encrypted_domain/real/real_eq_operators.sql
---! @brief Operators for public.eql_v3_real_eq.
+--! @brief Operators for public.{{prefix}}_real_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq
 );
diff --git a/packages/eql/src/v3/scalars/real/real_functions.sql b/packages/eql/src/v3/scalars/real/real_functions.sql
index 2d68e57ca..dbcfe5b47 100644
--- a/packages/eql/src/v3/scalars/real/real_functions.sql
+++ b/packages/eql/src/v3/scalars/real/real_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/real/real_functions.sql
---! @brief Functions for public.eql_v3_real.
+--! @brief Functions for public.{{prefix}}_real.
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_real never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text)
-RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$
+--! @return public.{{prefix}}_real never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real, selector text)
+RETURNS public.{{prefix}}_real IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_real never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer)
-RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$
+--! @return public.{{prefix}}_real never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real, selector integer)
+RETURNS public.{{prefix}}_real IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real right operand of the blocked operator
---! @return public.eql_v3_real never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real)
-RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$
+--! @param selector public.{{prefix}}_real right operand of the blocked operator
+--! @return public.{{prefix}}_real never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real)
+RETURNS public.{{prefix}}_real IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real right operand of the blocked operator
+--! @param selector public.{{prefix}}_real right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real, b public.{{prefix}}_real)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real left operand of the blocked operator
+--! @param a public.{{prefix}}_real left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real right operand of the blocked operator
+--! @param b public.{{prefix}}_real right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/real/real_operators.sql b/packages/eql/src/v3/scalars/real/real_operators.sql
index 99ed1e23d..f03c820e5 100644
--- a/packages/eql/src/v3/scalars/real/real_operators.sql
+++ b/packages/eql/src/v3/scalars/real/real_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/real/real_functions.sql
 
 --! @file encrypted_domain/real/real_operators.sql
---! @brief Operators for public.eql_v3_real.
+--! @brief Operators for public.{{prefix}}_real.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_real, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real
 );
diff --git a/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql b/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql
index 608c7f7f0..cb43ea23b 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_operators.sql
 
 --! @file encrypted_domain/real/real_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_real_ord.
+--! @brief Aggregates for public.{{prefix}}_real_ord.
 
---! @brief State function for min on public.eql_v3_real_ord.
---! @param state public.eql_v3_real_ord
---! @param value public.eql_v3_real_ord
---! @return public.eql_v3_real_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)
-RETURNS public.eql_v3_real_ord
+--! @brief State function for min on public.{{prefix}}_real_ord.
+--! @param state public.{{prefix}}_real_ord
+--! @param value public.{{prefix}}_real_ord
+--! @return public.{{prefix}}_real_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_real_ord, value public.{{prefix}}_real_ord)
+RETURNS public.{{prefix}}_real_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_real_ord.
---! @param input public.eql_v3_real_ord
---! @return public.eql_v3_real_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_real_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_real_ord.
+--! @param input public.{{prefix}}_real_ord
+--! @return public.{{prefix}}_real_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_real_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_real_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_real_ord.
---! @param state public.eql_v3_real_ord
---! @param value public.eql_v3_real_ord
---! @return public.eql_v3_real_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)
-RETURNS public.eql_v3_real_ord
+--! @brief State function for max on public.{{prefix}}_real_ord.
+--! @param state public.{{prefix}}_real_ord
+--! @param value public.{{prefix}}_real_ord
+--! @return public.{{prefix}}_real_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_real_ord, value public.{{prefix}}_real_ord)
+RETURNS public.{{prefix}}_real_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_real_ord.
---! @param input public.eql_v3_real_ord
---! @return public.eql_v3_real_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_real_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_real_ord.
+--! @param input public.{{prefix}}_real_ord
+--! @return public.{{prefix}}_real_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_real_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_real_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/real/real_ord_functions.sql b/packages/eql/src/v3/scalars/real/real_ord_functions.sql
index e3631653b..2b54c4312 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/real/real_ord_functions.sql
---! @brief Functions for public.eql_v3_real_ord.
+--! @brief Functions for public.{{prefix}}_real_ord.
 
---! @brief Index extractor for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_real_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
---! @param b public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
---! @param a public.eql_v3_real_ord
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
+--! @param a public.{{prefix}}_real_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord
+--! @param b public.{{prefix}}_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text)
-RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$
+--! @return public.{{prefix}}_real_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord, selector text)
+RETURNS public.{{prefix}}_real_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer)
-RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$
+--! @return public.{{prefix}}_real_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord, selector integer)
+RETURNS public.{{prefix}}_real_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_ord right operand of the blocked operator
---! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord)
-RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$
+--! @param selector public.{{prefix}}_real_ord right operand of the blocked operator
+--! @return public.{{prefix}}_real_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_ord)
+RETURNS public.{{prefix}}_real_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql
index de285158c..ec99c5f40 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_ope_operators.sql
 
 --! @file encrypted_domain/real/real_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_real_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_real_ord_ope.
 
---! @brief State function for min on public.eql_v3_real_ord_ope.
---! @param state public.eql_v3_real_ord_ope
---! @param value public.eql_v3_real_ord_ope
---! @return public.eql_v3_real_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)
-RETURNS public.eql_v3_real_ord_ope
+--! @brief State function for min on public.{{prefix}}_real_ord_ope.
+--! @param state public.{{prefix}}_real_ord_ope
+--! @param value public.{{prefix}}_real_ord_ope
+--! @return public.{{prefix}}_real_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_real_ord_ope, value public.{{prefix}}_real_ord_ope)
+RETURNS public.{{prefix}}_real_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_real_ord_ope.
---! @param input public.eql_v3_real_ord_ope
---! @return public.eql_v3_real_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_real_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_real_ord_ope.
+--! @param input public.{{prefix}}_real_ord_ope
+--! @return public.{{prefix}}_real_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_real_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_real_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_real_ord_ope.
---! @param state public.eql_v3_real_ord_ope
---! @param value public.eql_v3_real_ord_ope
---! @return public.eql_v3_real_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)
-RETURNS public.eql_v3_real_ord_ope
+--! @brief State function for max on public.{{prefix}}_real_ord_ope.
+--! @param state public.{{prefix}}_real_ord_ope
+--! @param value public.{{prefix}}_real_ord_ope
+--! @return public.{{prefix}}_real_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_real_ord_ope, value public.{{prefix}}_real_ord_ope)
+RETURNS public.{{prefix}}_real_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_real_ord_ope.
---! @param input public.eql_v3_real_ord_ope
---! @return public.eql_v3_real_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_real_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_real_ord_ope.
+--! @param input public.{{prefix}}_real_ord_ope
+--! @return public.{{prefix}}_real_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_real_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_real_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql b/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql
index 18da5b294..7143e3fa6 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/real/real_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_real_ord_ope.
+--! @brief Functions for public.{{prefix}}_real_ord_ope.
 
---! @brief Index extractor for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_real_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
---! @param b public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
---! @param a public.eql_v3_real_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
+--! @param a public.{{prefix}}_real_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ope
+--! @param b public.{{prefix}}_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text)
-RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$
+--! @return public.{{prefix}}_real_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ope, selector text)
+RETURNS public.{{prefix}}_real_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer)
-RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$
+--! @return public.{{prefix}}_real_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ope, selector integer)
+RETURNS public.{{prefix}}_real_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator
---! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope)
-RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_real_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_real_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_ord_ope)
+RETURNS public.{{prefix}}_real_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql b/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql
index c11db40a3..310f1264b 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_ope_functions.sql
 
 --! @file encrypted_domain/real/real_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_real_ord_ope.
+--! @brief Operators for public.{{prefix}}_real_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/real/real_ord_operators.sql b/packages/eql/src/v3/scalars/real/real_ord_operators.sql
index b5b3692b1..922e70ab4 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_functions.sql
 
 --! @file encrypted_domain/real/real_ord_operators.sql
---! @brief Operators for public.eql_v3_real_ord.
+--! @brief Operators for public.{{prefix}}_real_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord
 );
diff --git a/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql
index 60abf7116..e9708bacb 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_ore_operators.sql
 
 --! @file encrypted_domain/real/real_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_real_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_real_ord_ore.
 
---! @brief State function for min on public.eql_v3_real_ord_ore.
---! @param state public.eql_v3_real_ord_ore
---! @param value public.eql_v3_real_ord_ore
---! @return public.eql_v3_real_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)
-RETURNS public.eql_v3_real_ord_ore
+--! @brief State function for min on public.{{prefix}}_real_ord_ore.
+--! @param state public.{{prefix}}_real_ord_ore
+--! @param value public.{{prefix}}_real_ord_ore
+--! @return public.{{prefix}}_real_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_real_ord_ore, value public.{{prefix}}_real_ord_ore)
+RETURNS public.{{prefix}}_real_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_real_ord_ore.
---! @param input public.eql_v3_real_ord_ore
---! @return public.eql_v3_real_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_real_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_real_ord_ore.
+--! @param input public.{{prefix}}_real_ord_ore
+--! @return public.{{prefix}}_real_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_real_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_real_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_real_ord_ore.
---! @param state public.eql_v3_real_ord_ore
---! @param value public.eql_v3_real_ord_ore
---! @return public.eql_v3_real_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)
-RETURNS public.eql_v3_real_ord_ore
+--! @brief State function for max on public.{{prefix}}_real_ord_ore.
+--! @param state public.{{prefix}}_real_ord_ore
+--! @param value public.{{prefix}}_real_ord_ore
+--! @return public.{{prefix}}_real_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_real_ord_ore, value public.{{prefix}}_real_ord_ore)
+RETURNS public.{{prefix}}_real_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_real_ord_ore.
---! @param input public.eql_v3_real_ord_ore
---! @return public.eql_v3_real_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_real_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_real_ord_ore.
+--! @param input public.{{prefix}}_real_ord_ore
+--! @return public.{{prefix}}_real_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_real_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_real_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql b/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql
index bbc01055f..c88e2b5b9 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/real/real_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_real_ord_ore.
+--! @brief Functions for public.{{prefix}}_real_ord_ore.
 
---! @brief Index extractor for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_real_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
---! @param b public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
---! @param a public.eql_v3_real_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
+--! @param a public.{{prefix}}_real_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_real_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_real_ord_ore
+--! @param b public.{{prefix}}_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text)
-RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$
+--! @return public.{{prefix}}_real_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ore, selector text)
+RETURNS public.{{prefix}}_real_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer)
-RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$
+--! @return public.{{prefix}}_real_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ore, selector integer)
+RETURNS public.{{prefix}}_real_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator
---! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore)
-RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_real_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_real_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_ord_ore)
+RETURNS public.{{prefix}}_real_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql b/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql
index bb5fb6d9e..5702adba4 100644
--- a/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/real/real_ord_ore_functions.sql
 
 --! @file encrypted_domain/real/real_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_real_ord_ore.
+--! @brief Operators for public.{{prefix}}_real_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/real/real_types.sql b/packages/eql/src/v3/scalars/real/real_types.sql
index 94087d16d..186fe4d4f 100644
--- a/packages/eql/src/v3/scalars/real/real_types.sql
+++ b/packages/eql/src/v3/scalars/real/real_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_real.
+  --! @brief Encrypted domain public.{{prefix}}_real.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_real' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_real AS jsonb
+    CREATE DOMAIN public.{{prefix}}_real AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_real IS 'EQL encrypted real (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_real_eq.
+  --! @brief Encrypted domain public.{{prefix}}_real_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_real_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_real_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_real_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_real_eq IS 'EQL encrypted real (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_real_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_real_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_real_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_real_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_real_ord_ore IS 'EQL encrypted real (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_real_ord.
+  --! @brief Encrypted domain public.{{prefix}}_real_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_real_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_real_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_real_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_real_ord IS 'EQL encrypted real (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_real_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_real_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_real_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_real_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_real_ord_ope IS 'EQL encrypted real (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql
index 6d6a55848..44fd8e299 100644
--- a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql
@@ -7,244 +7,244 @@
 -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
 
 --! @file encrypted_domain/smallint/json_entry_smallint_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_smallint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_smallint_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_smallint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_smallint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_smallint_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_smallint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_smallint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_smallint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql
index 3ccb0894d..81ba7ff66 100644
--- a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql
@@ -5,140 +5,140 @@
 -- REQUIRE: src/v3/scalars/smallint/json_entry_smallint_functions.sql
 
 --! @file encrypted_domain/smallint/json_entry_smallint_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql
index b41e5b564..15357ca4a 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_eq_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_eq_functions.sql
---! @brief Functions for eql_v3.query_smallint_eq.
+--! @brief Functions for {{prefix}}.query_smallint_eq.
 
---! @brief Index extractor for eql_v3.query_smallint_eq.
---! @param a eql_v3.query_smallint_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_smallint_eq.
+--! @param a {{prefix}}.query_smallint_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_smallint_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_eq.
---! @param a public.eql_v3_smallint_eq
---! @param b eql_v3.query_smallint_eq
+--! @brief Operator wrapper for {{prefix}}.query_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
+--! @param b {{prefix}}.query_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_eq, b {{prefix}}.query_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_eq.
---! @param a eql_v3.query_smallint_eq
---! @param b public.eql_v3_smallint_eq
+--! @brief Operator wrapper for {{prefix}}.query_smallint_eq.
+--! @param a {{prefix}}.query_smallint_eq
+--! @param b public.{{prefix}}_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_eq.
---! @param a public.eql_v3_smallint_eq
---! @param b eql_v3.query_smallint_eq
+--! @brief Operator wrapper for {{prefix}}.query_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
+--! @param b {{prefix}}.query_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_eq, b {{prefix}}.query_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_eq.
---! @param a eql_v3.query_smallint_eq
---! @param b public.eql_v3_smallint_eq
+--! @brief Operator wrapper for {{prefix}}.query_smallint_eq.
+--! @param a {{prefix}}.query_smallint_eq
+--! @param b public.{{prefix}}_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql
index c85625f7b..1d91a489c 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/smallint/query_smallint_eq_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_eq_operators.sql
---! @brief Operators for eql_v3.query_smallint_eq.
+--! @brief Operators for {{prefix}}.query_smallint_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = {{prefix}}.query_smallint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = {{prefix}}.query_smallint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql
index 21a1d8f7c..59d9eda07 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_ord_functions.sql
---! @brief Functions for eql_v3.query_smallint_ord.
+--! @brief Functions for {{prefix}}.query_smallint_ord.
 
---! @brief Index extractor for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_smallint_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b eql_v3.query_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b {{prefix}}.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord.
---! @param a eql_v3.query_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord.
+--! @param a {{prefix}}.query_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
index 00dc12361..0b14e0831 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_smallint_ord_ope.
+--! @brief Functions for {{prefix}}.query_smallint_ord_ope.
 
---! @brief Index extractor for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_smallint_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b eql_v3.query_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b {{prefix}}.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
---! @param a eql_v3.query_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope.
+--! @param a {{prefix}}.query_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql
index 1b8480f2e..0f37d5b4e 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_smallint_ord_ope.
+--! @brief Operators for {{prefix}}.query_smallint_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql
index 5f66128fc..73dc194f7 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_ord_operators.sql
---! @brief Operators for eql_v3.query_smallint_ord.
+--! @brief Operators for {{prefix}}.query_smallint_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
index b85135a3c..8d898cf4a 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_smallint_ord_ore.
+--! @brief Functions for {{prefix}}.query_smallint_ord_ore.
 
---! @brief Index extractor for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_smallint_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b eql_v3.query_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b {{prefix}}.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b eql_v3.query_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b {{prefix}}.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b eql_v3.query_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b {{prefix}}.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b eql_v3.query_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b {{prefix}}.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b eql_v3.query_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b {{prefix}}.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b eql_v3.query_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b {{prefix}}.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
---! @param a eql_v3.query_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore.
+--! @param a {{prefix}}.query_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql
index d71111770..85bccdbf8 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
 
 --! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_smallint_ord_ore.
+--! @brief Operators for {{prefix}}.query_smallint_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql
index d2c4a334a..382dc375f 100644
--- a/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql
+++ b/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/smallint/query_smallint_types.sql
 --! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_smallint_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_smallint_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_smallint_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_smallint_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_smallint_eq IS 'EQL smallint query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_smallint_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_smallint_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_smallint_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_smallint_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_smallint_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_smallint_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_smallint_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_smallint_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_smallint_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql
index 3721f5af3..ec5cf4911 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/smallint/smallint_eq_functions.sql
---! @brief Functions for public.eql_v3_smallint_eq.
+--! @brief Functions for public.{{prefix}}_smallint_eq.
 
---! @brief Index extractor for public.eql_v3_smallint_eq.
---! @param a public.eql_v3_smallint_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_smallint_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_eq.
---! @param a public.eql_v3_smallint_eq
---! @param b public.eql_v3_smallint_eq
+--! @brief Operator wrapper for public.{{prefix}}_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
+--! @param b public.{{prefix}}_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_eq.
---! @param a public.eql_v3_smallint_eq
+--! @brief Operator wrapper for public.{{prefix}}_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_smallint_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_eq.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_eq.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_eq
+--! @param b public.{{prefix}}_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_smallint_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_eq.
---! @param a public.eql_v3_smallint_eq
---! @param b public.eql_v3_smallint_eq
+--! @brief Operator wrapper for public.{{prefix}}_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
+--! @param b public.{{prefix}}_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_eq.
---! @param a public.eql_v3_smallint_eq
+--! @brief Operator wrapper for public.{{prefix}}_smallint_eq.
+--! @param a public.{{prefix}}_smallint_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_smallint_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_eq.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_eq.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_eq
+--! @param b public.{{prefix}}_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_smallint_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text)
-RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$
+--! @return public.{{prefix}}_smallint_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_eq, selector text)
+RETURNS public.{{prefix}}_smallint_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer)
-RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$
+--! @return public.{{prefix}}_smallint_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_eq, selector integer)
+RETURNS public.{{prefix}}_smallint_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_eq right operand of the blocked operator
---! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq)
-RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$
+--! @param selector public.{{prefix}}_smallint_eq right operand of the blocked operator
+--! @return public.{{prefix}}_smallint_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_eq)
+RETURNS public.{{prefix}}_smallint_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql
index d69ab9fa8..2cbc24904 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_eq_functions.sql
 
 --! @file encrypted_domain/smallint/smallint_eq_operators.sql
---! @brief Operators for public.eql_v3_smallint_eq.
+--! @brief Operators for public.{{prefix}}_smallint_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_functions.sql
index 3423c9a39..9f6e5462f 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/smallint/smallint_functions.sql
---! @brief Functions for public.eql_v3_smallint.
+--! @brief Functions for public.{{prefix}}_smallint.
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_smallint never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text)
-RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$
+--! @return public.{{prefix}}_smallint never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint, selector text)
+RETURNS public.{{prefix}}_smallint IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_smallint never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer)
-RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$
+--! @return public.{{prefix}}_smallint never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint, selector integer)
+RETURNS public.{{prefix}}_smallint IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint right operand of the blocked operator
---! @return public.eql_v3_smallint never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint)
-RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$
+--! @param selector public.{{prefix}}_smallint right operand of the blocked operator
+--! @return public.{{prefix}}_smallint never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint)
+RETURNS public.{{prefix}}_smallint IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint right operand of the blocked operator
+--! @param selector public.{{prefix}}_smallint right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_operators.sql
index b249a6835..a05eb5038 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_functions.sql
 
 --! @file encrypted_domain/smallint/smallint_operators.sql
---! @brief Operators for public.eql_v3_smallint.
+--! @brief Operators for public.{{prefix}}_smallint.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql
index d5b3b6bc3..b9806af5a 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_operators.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_smallint_ord.
+--! @brief Aggregates for public.{{prefix}}_smallint_ord.
 
---! @brief State function for min on public.eql_v3_smallint_ord.
---! @param state public.eql_v3_smallint_ord
---! @param value public.eql_v3_smallint_ord
---! @return public.eql_v3_smallint_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)
-RETURNS public.eql_v3_smallint_ord
+--! @brief State function for min on public.{{prefix}}_smallint_ord.
+--! @param state public.{{prefix}}_smallint_ord
+--! @param value public.{{prefix}}_smallint_ord
+--! @return public.{{prefix}}_smallint_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_smallint_ord, value public.{{prefix}}_smallint_ord)
+RETURNS public.{{prefix}}_smallint_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_smallint_ord.
---! @param input public.eql_v3_smallint_ord
---! @return public.eql_v3_smallint_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_smallint_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_smallint_ord.
+--! @param input public.{{prefix}}_smallint_ord
+--! @return public.{{prefix}}_smallint_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_smallint_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_smallint_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_smallint_ord.
---! @param state public.eql_v3_smallint_ord
---! @param value public.eql_v3_smallint_ord
---! @return public.eql_v3_smallint_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)
-RETURNS public.eql_v3_smallint_ord
+--! @brief State function for max on public.{{prefix}}_smallint_ord.
+--! @param state public.{{prefix}}_smallint_ord
+--! @param value public.{{prefix}}_smallint_ord
+--! @return public.{{prefix}}_smallint_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_smallint_ord, value public.{{prefix}}_smallint_ord)
+RETURNS public.{{prefix}}_smallint_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_smallint_ord.
---! @param input public.eql_v3_smallint_ord
---! @return public.eql_v3_smallint_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_smallint_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_smallint_ord.
+--! @param input public.{{prefix}}_smallint_ord
+--! @return public.{{prefix}}_smallint_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_smallint_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_smallint_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql
index 705a8556c..973876d47 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_functions.sql
---! @brief Functions for public.eql_v3_smallint_ord.
+--! @brief Functions for public.{{prefix}}_smallint_ord.
 
---! @brief Index extractor for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_smallint_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
---! @param b public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
---! @param a public.eql_v3_smallint_ord
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
+--! @param a public.{{prefix}}_smallint_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord
+--! @param b public.{{prefix}}_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector text)
-RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$
+--! @return public.{{prefix}}_smallint_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord, selector text)
+RETURNS public.{{prefix}}_smallint_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector integer)
-RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$
+--! @return public.{{prefix}}_smallint_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord, selector integer)
+RETURNS public.{{prefix}}_smallint_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_ord right operand of the blocked operator
---! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord)
-RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$
+--! @param selector public.{{prefix}}_smallint_ord right operand of the blocked operator
+--! @return public.{{prefix}}_smallint_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_ord)
+RETURNS public.{{prefix}}_smallint_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql
index 2798573b8..dbb9bed18 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_operators.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_smallint_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_smallint_ord_ope.
 
---! @brief State function for min on public.eql_v3_smallint_ord_ope.
---! @param state public.eql_v3_smallint_ord_ope
---! @param value public.eql_v3_smallint_ord_ope
---! @return public.eql_v3_smallint_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)
-RETURNS public.eql_v3_smallint_ord_ope
+--! @brief State function for min on public.{{prefix}}_smallint_ord_ope.
+--! @param state public.{{prefix}}_smallint_ord_ope
+--! @param value public.{{prefix}}_smallint_ord_ope
+--! @return public.{{prefix}}_smallint_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_smallint_ord_ope, value public.{{prefix}}_smallint_ord_ope)
+RETURNS public.{{prefix}}_smallint_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_smallint_ord_ope.
---! @param input public.eql_v3_smallint_ord_ope
---! @return public.eql_v3_smallint_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_smallint_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_smallint_ord_ope.
+--! @param input public.{{prefix}}_smallint_ord_ope
+--! @return public.{{prefix}}_smallint_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_smallint_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_smallint_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_smallint_ord_ope.
---! @param state public.eql_v3_smallint_ord_ope
---! @param value public.eql_v3_smallint_ord_ope
---! @return public.eql_v3_smallint_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)
-RETURNS public.eql_v3_smallint_ord_ope
+--! @brief State function for max on public.{{prefix}}_smallint_ord_ope.
+--! @param state public.{{prefix}}_smallint_ord_ope
+--! @param value public.{{prefix}}_smallint_ord_ope
+--! @return public.{{prefix}}_smallint_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_smallint_ord_ope, value public.{{prefix}}_smallint_ord_ope)
+RETURNS public.{{prefix}}_smallint_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_smallint_ord_ope.
---! @param input public.eql_v3_smallint_ord_ope
---! @return public.eql_v3_smallint_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_smallint_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_smallint_ord_ope.
+--! @param input public.{{prefix}}_smallint_ord_ope
+--! @return public.{{prefix}}_smallint_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_smallint_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_smallint_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql
index 307f01c0f..0c1d4ee14 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_smallint_ord_ope.
+--! @brief Functions for public.{{prefix}}_smallint_ord_ope.
 
---! @brief Index extractor for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_smallint_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
---! @param b public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
---! @param a public.eql_v3_smallint_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
+--! @param a public.{{prefix}}_smallint_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ope
+--! @param b public.{{prefix}}_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector text)
-RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$
+--! @return public.{{prefix}}_smallint_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ope, selector text)
+RETURNS public.{{prefix}}_smallint_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector integer)
-RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$
+--! @return public.{{prefix}}_smallint_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ope, selector integer)
+RETURNS public.{{prefix}}_smallint_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator
---! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ope)
-RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_smallint_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_ord_ope)
+RETURNS public.{{prefix}}_smallint_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql
index 3f45121ed..826c80e22 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_functions.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_smallint_ord_ope.
+--! @brief Operators for public.{{prefix}}_smallint_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql
index b5efb730c..8de4d09bc 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_functions.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_operators.sql
---! @brief Operators for public.eql_v3_smallint_ord.
+--! @brief Operators for public.{{prefix}}_smallint_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql
index e59ea3bdd..491699a6f 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_operators.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_smallint_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_smallint_ord_ore.
 
---! @brief State function for min on public.eql_v3_smallint_ord_ore.
---! @param state public.eql_v3_smallint_ord_ore
---! @param value public.eql_v3_smallint_ord_ore
---! @return public.eql_v3_smallint_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)
-RETURNS public.eql_v3_smallint_ord_ore
+--! @brief State function for min on public.{{prefix}}_smallint_ord_ore.
+--! @param state public.{{prefix}}_smallint_ord_ore
+--! @param value public.{{prefix}}_smallint_ord_ore
+--! @return public.{{prefix}}_smallint_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_smallint_ord_ore, value public.{{prefix}}_smallint_ord_ore)
+RETURNS public.{{prefix}}_smallint_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_smallint_ord_ore.
---! @param input public.eql_v3_smallint_ord_ore
---! @return public.eql_v3_smallint_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_smallint_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_smallint_ord_ore.
+--! @param input public.{{prefix}}_smallint_ord_ore
+--! @return public.{{prefix}}_smallint_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_smallint_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_smallint_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_smallint_ord_ore.
---! @param state public.eql_v3_smallint_ord_ore
---! @param value public.eql_v3_smallint_ord_ore
---! @return public.eql_v3_smallint_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)
-RETURNS public.eql_v3_smallint_ord_ore
+--! @brief State function for max on public.{{prefix}}_smallint_ord_ore.
+--! @param state public.{{prefix}}_smallint_ord_ore
+--! @param value public.{{prefix}}_smallint_ord_ore
+--! @return public.{{prefix}}_smallint_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_smallint_ord_ore, value public.{{prefix}}_smallint_ord_ore)
+RETURNS public.{{prefix}}_smallint_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_smallint_ord_ore.
---! @param input public.eql_v3_smallint_ord_ore
---! @return public.eql_v3_smallint_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_smallint_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_smallint_ord_ore.
+--! @param input public.{{prefix}}_smallint_ord_ore
+--! @return public.{{prefix}}_smallint_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_smallint_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_smallint_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql
index ae14169f0..4940f690f 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_smallint_ord_ore.
+--! @brief Functions for public.{{prefix}}_smallint_ord_ore.
 
---! @brief Index extractor for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_smallint_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
---! @param b public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
---! @param a public.eql_v3_smallint_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
+--! @param a public.{{prefix}}_smallint_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_smallint_ord_ore
+--! @param b public.{{prefix}}_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector text)
-RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$
+--! @return public.{{prefix}}_smallint_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ore, selector text)
+RETURNS public.{{prefix}}_smallint_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector integer)
-RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$
+--! @return public.{{prefix}}_smallint_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ore, selector integer)
+RETURNS public.{{prefix}}_smallint_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator
---! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ore)
-RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_smallint_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_ord_ore)
+RETURNS public.{{prefix}}_smallint_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql
index 602a85417..694f2b2a8 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_functions.sql
 
 --! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_smallint_ord_ore.
+--! @brief Operators for public.{{prefix}}_smallint_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/smallint/smallint_types.sql b/packages/eql/src/v3/scalars/smallint/smallint_types.sql
index 8a4044a86..adc4887ca 100644
--- a/packages/eql/src/v3/scalars/smallint/smallint_types.sql
+++ b/packages/eql/src/v3/scalars/smallint/smallint_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_smallint.
+  --! @brief Encrypted domain public.{{prefix}}_smallint.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_smallint' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_smallint AS jsonb
+    CREATE DOMAIN public.{{prefix}}_smallint AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_smallint IS 'EQL encrypted smallint (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_smallint_eq.
+  --! @brief Encrypted domain public.{{prefix}}_smallint_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_smallint_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_smallint_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_smallint_eq IS 'EQL encrypted smallint (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_smallint_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_smallint_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_smallint_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_smallint_ord.
+  --! @brief Encrypted domain public.{{prefix}}_smallint_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_smallint_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_smallint_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_smallint_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_smallint_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_smallint_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql b/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql
index 054e48c7a..57c5d45bc 100644
--- a/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql
+++ b/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql
@@ -7,412 +7,412 @@
 -- REQUIRE: src/v3/scalars/text/query_text_ord_ope_functions.sql
 
 --! @file encrypted_domain/text/json_entry_text_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a public.eql_v3_json_entry
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a public.{{prefix}}_json_entry
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_json_entry.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_json_entry
+--! @brief Operator wrapper for public.{{prefix}}_json_entry.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_json_entry
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_search left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_search left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_search left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_search left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_search left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_text_search left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql b/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql
index 4f98a385b..029d55e8c 100644
--- a/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql
+++ b/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql
@@ -5,200 +5,200 @@
 -- REQUIRE: src/v3/scalars/text/json_entry_text_functions.sql
 
 --! @file encrypted_domain/text/json_entry_text_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql b/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql
index d0c0cc2e9..0e6260a19 100644
--- a/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/text/text_eq_functions.sql
 
 --! @file encrypted_domain/text/query_text_eq_functions.sql
---! @brief Functions for eql_v3.query_text_eq.
+--! @brief Functions for {{prefix}}.query_text_eq.
 
---! @brief Index extractor for eql_v3.query_text_eq.
---! @param a eql_v3.query_text_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_text_eq.
+--! @param a {{prefix}}.query_text_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_eq.
---! @param a public.eql_v3_text_eq
---! @param b eql_v3.query_text_eq
+--! @brief Operator wrapper for {{prefix}}.query_text_eq.
+--! @param a public.{{prefix}}_text_eq
+--! @param b {{prefix}}.query_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_eq, b {{prefix}}.query_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_eq.
---! @param a eql_v3.query_text_eq
---! @param b public.eql_v3_text_eq
+--! @brief Operator wrapper for {{prefix}}.query_text_eq.
+--! @param a {{prefix}}.query_text_eq
+--! @param b public.{{prefix}}_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_eq.
---! @param a public.eql_v3_text_eq
---! @param b eql_v3.query_text_eq
+--! @brief Operator wrapper for {{prefix}}.query_text_eq.
+--! @param a public.{{prefix}}_text_eq
+--! @param b {{prefix}}.query_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_eq, b {{prefix}}.query_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_eq.
---! @param a eql_v3.query_text_eq
---! @param b public.eql_v3_text_eq
+--! @brief Operator wrapper for {{prefix}}.query_text_eq.
+--! @param a {{prefix}}.query_text_eq
+--! @param b public.{{prefix}}_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql b/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql
index 912b0c0c4..08ad73c9c 100644
--- a/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/text/query_text_eq_functions.sql
 
 --! @file encrypted_domain/text/query_text_eq_operators.sql
---! @brief Operators for eql_v3.query_text_eq.
+--! @brief Operators for {{prefix}}.query_text_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = {{prefix}}.query_text_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_text_eq, RIGHTARG = public.{{prefix}}_text_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = {{prefix}}.query_text_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_text_eq, RIGHTARG = public.{{prefix}}_text_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_match_functions.sql b/packages/eql/src/v3/scalars/text/query_text_match_functions.sql
index 21d85ed57..e877edf21 100644
--- a/packages/eql/src/v3/scalars/text/query_text_match_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_match_functions.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/text/text_match_functions.sql
 
 --! @file encrypted_domain/text/query_text_match_functions.sql
---! @brief Functions for eql_v3.query_text_match.
+--! @brief Functions for {{prefix}}.query_text_match.
 
---! @brief Index extractor for eql_v3.query_text_match.
---! @param a eql_v3.query_text_match
---! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)
-RETURNS eql_v3_internal.bloom_filter
+--! @brief Index extractor for {{prefix}}.query_text_match.
+--! @param a {{prefix}}.query_text_match
+--! @return {{prefix}}_internal.bloom_filter
+CREATE FUNCTION {{prefix}}.match_term(a {{prefix}}.query_text_match)
+RETURNS {{prefix}}_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_match.
---! @param a public.eql_v3_text_match
---! @param b eql_v3.query_text_match
+--! @brief Operator wrapper for {{prefix}}.query_text_match.
+--! @param a public.{{prefix}}_text_match
+--! @param b {{prefix}}.query_text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_match, b {{prefix}}.query_text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_match.
---! @param a eql_v3.query_text_match
---! @param b public.eql_v3_text_match
+--! @brief Operator wrapper for {{prefix}}.query_text_match.
+--! @param a {{prefix}}.query_text_match
+--! @param b public.{{prefix}}_text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}.matches(a {{prefix}}.query_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_match_operators.sql b/packages/eql/src/v3/scalars/text/query_text_match_operators.sql
index 8a510552d..91dc013b8 100644
--- a/packages/eql/src/v3/scalars/text/query_text_match_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_match_operators.sql
@@ -4,16 +4,16 @@
 -- REQUIRE: src/v3/scalars/text/query_text_match_functions.sql
 
 --! @file encrypted_domain/text/query_text_match_operators.sql
---! @brief Operators for eql_v3.query_text_match.
+--! @brief Operators for {{prefix}}.query_text_match.
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = {{prefix}}.query_text_match,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = {{prefix}}.query_text_match, RIGHTARG = public.{{prefix}}_text_match,
   RESTRICT = contsel, JOIN = contjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql b/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql
index d2c1b932e..e54be6f50 100644
--- a/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql
@@ -4,116 +4,116 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_functions.sql
 
 --! @file encrypted_domain/text/query_text_ord_functions.sql
---! @brief Functions for eql_v3.query_text_ord.
+--! @brief Functions for {{prefix}}.query_text_ord.
 
---! @brief Index extractor for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_ord)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_text_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b eql_v3.query_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b {{prefix}}.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord.
---! @param a eql_v3.query_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for {{prefix}}.query_text_ord.
+--! @param a {{prefix}}.query_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql
index 7a111d47d..6ddd10e43 100644
--- a/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql
@@ -4,116 +4,116 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_ope_functions.sql
 
 --! @file encrypted_domain/text/query_text_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_text_ord_ope.
+--! @brief Functions for {{prefix}}.query_text_ord_ope.
 
---! @brief Index extractor for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_ord_ope)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_text_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b eql_v3.query_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b {{prefix}}.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ope.
---! @param a eql_v3.query_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope.
+--! @param a {{prefix}}.query_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql
index 50f68e8b7..2e15e64d4 100644
--- a/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/text/query_text_ord_ope_functions.sql
 
 --! @file encrypted_domain/text/query_text_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_text_ord_ope.
+--! @brief Operators for {{prefix}}.query_text_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql b/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql
index 0e7d9be4b..8313a604a 100644
--- a/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/text/query_text_ord_functions.sql
 
 --! @file encrypted_domain/text/query_text_ord_operators.sql
---! @brief Operators for eql_v3.query_text_ord.
+--! @brief Operators for {{prefix}}.query_text_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql
index d790a4396..f0f4b99f2 100644
--- a/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql
@@ -4,116 +4,116 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_ore_functions.sql
 
 --! @file encrypted_domain/text/query_text_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_text_ord_ore.
+--! @brief Functions for {{prefix}}.query_text_ord_ore.
 
---! @brief Index extractor for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_ord_ore)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_text_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b eql_v3.query_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b {{prefix}}.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b eql_v3.query_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b {{prefix}}.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b eql_v3.query_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b {{prefix}}.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b eql_v3.query_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b {{prefix}}.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b eql_v3.query_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b {{prefix}}.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b eql_v3.query_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b {{prefix}}.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_ord_ore.
---! @param a eql_v3.query_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore.
+--! @param a {{prefix}}.query_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql
index a7526f6f9..52d75e747 100644
--- a/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/text/query_text_ord_ore_functions.sql
 
 --! @file encrypted_domain/text/query_text_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_text_ord_ore.
+--! @brief Operators for {{prefix}}.query_text_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_search_functions.sql b/packages/eql/src/v3/scalars/text/query_text_search_functions.sql
index c5f472ac1..0bc6d563b 100644
--- a/packages/eql/src/v3/scalars/text/query_text_search_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_search_functions.sql
@@ -4,140 +4,140 @@
 -- REQUIRE: src/v3/scalars/text/text_search_functions.sql
 
 --! @file encrypted_domain/text/query_text_search_functions.sql
---! @brief Functions for eql_v3.query_text_search.
+--! @brief Functions for {{prefix}}.query_text_search.
 
---! @brief Index extractor for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_search)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_text_search)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)
-RETURNS eql_v3_internal.bloom_filter
+--! @brief Index extractor for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @return {{prefix}}_internal.bloom_filter
+CREATE FUNCTION {{prefix}}.match_term(a {{prefix}}.query_text_search)
+RETURNS {{prefix}}_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a public.eql_v3_text_search
---! @param b eql_v3.query_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b {{prefix}}.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search.
---! @param a eql_v3.query_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for {{prefix}}.query_text_search.
+--! @param a {{prefix}}.query_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.matches(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_search_operators.sql b/packages/eql/src/v3/scalars/text/query_text_search_operators.sql
index 6a5502c37..546618c7e 100644
--- a/packages/eql/src/v3/scalars/text/query_text_search_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_search_operators.sql
@@ -4,88 +4,88 @@
 -- REQUIRE: src/v3/scalars/text/query_text_search_functions.sql
 
 --! @file encrypted_domain/text/query_text_search_operators.sql
---! @brief Operators for eql_v3.query_text_search.
+--! @brief Operators for {{prefix}}.query_text_search.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search,
   RESTRICT = contsel, JOIN = contjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql b/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql
index 205a47be1..4f1f4e94a 100644
--- a/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql
@@ -4,140 +4,140 @@
 -- REQUIRE: src/v3/scalars/text/text_search_ore_functions.sql
 
 --! @file encrypted_domain/text/query_text_search_ore_functions.sql
---! @brief Functions for eql_v3.query_text_search_ore.
+--! @brief Functions for {{prefix}}.query_text_search_ore.
 
---! @brief Index extractor for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_search_ore)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_text_search_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Index extractor for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)
-RETURNS eql_v3_internal.bloom_filter
+--! @brief Index extractor for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @return {{prefix}}_internal.bloom_filter
+CREATE FUNCTION {{prefix}}.match_term(a {{prefix}}.query_text_search_ore)
+RETURNS {{prefix}}_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b eql_v3.query_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b {{prefix}}.query_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for eql_v3.query_text_search_ore.
---! @param a eql_v3.query_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for {{prefix}}.query_text_search_ore.
+--! @param a {{prefix}}.query_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.matches(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
diff --git a/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql b/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql
index 0a78693fe..1d148ee5f 100644
--- a/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql
@@ -4,88 +4,88 @@
 -- REQUIRE: src/v3/scalars/text/query_text_search_ore_functions.sql
 
 --! @file encrypted_domain/text/query_text_search_ore_operators.sql
---! @brief Operators for eql_v3.query_text_search_ore.
+--! @brief Operators for {{prefix}}.query_text_search_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   RESTRICT = contsel, JOIN = contjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/text/query_text_types.sql b/packages/eql/src/v3/scalars/text/query_text_types.sql
index eec1a886e..9360a9fbf 100644
--- a/packages/eql/src/v3/scalars/text/query_text_types.sql
+++ b/packages/eql/src/v3/scalars/text/query_text_types.sql
@@ -3,59 +3,59 @@
 
 --! @file v3/scalars/text/query_text_types.sql
 --! @brief Query-operand domains for text (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_text_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_eq IS 'EQL text query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_match (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_match' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_match AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_match AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'bf'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_match IS 'EQL text query operand (matching)';
 
-  --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -65,18 +65,18 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,18 +84,18 @@ BEGIN
         AND VALUE ? 'hm'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_ord IS 'EQL text query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -103,18 +103,18 @@ BEGIN
         AND VALUE ? 'hm'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_search_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_search_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_search_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -125,18 +125,18 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';
 
-  --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_text_search (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_text_search' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_text_search AS jsonb
+    CREATE DOMAIN {{prefix}}.query_text_search AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -145,10 +145,10 @@ BEGIN
         AND VALUE ? 'op'
         AND VALUE ? 'bf'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';
+  COMMENT ON DOMAIN {{prefix}}.query_text_search IS 'EQL text query operand (equality, ordering, matching)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/text/text_eq_functions.sql b/packages/eql/src/v3/scalars/text/text_eq_functions.sql
index 2bdd95fcf..bbdc0441f 100644
--- a/packages/eql/src/v3/scalars/text/text_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/text/text_eq_functions.sql
---! @brief Functions for public.eql_v3_text_eq.
+--! @brief Functions for public.{{prefix}}_text_eq.
 
---! @brief Index extractor for public.eql_v3_text_eq.
---! @param a public.eql_v3_text_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_text_eq.
+--! @param a public.{{prefix}}_text_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_eq.
---! @param a public.eql_v3_text_eq
---! @param b public.eql_v3_text_eq
+--! @brief Operator wrapper for public.{{prefix}}_text_eq.
+--! @param a public.{{prefix}}_text_eq
+--! @param b public.{{prefix}}_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_eq.
---! @param a public.eql_v3_text_eq
+--! @brief Operator wrapper for public.{{prefix}}_text_eq.
+--! @param a public.{{prefix}}_text_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_eq.
+--! @brief Operator wrapper for public.{{prefix}}_text_eq.
 --! @param a jsonb
---! @param b public.eql_v3_text_eq
+--! @param b public.{{prefix}}_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_eq.
---! @param a public.eql_v3_text_eq
---! @param b public.eql_v3_text_eq
+--! @brief Operator wrapper for public.{{prefix}}_text_eq.
+--! @param a public.{{prefix}}_text_eq
+--! @param b public.{{prefix}}_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_eq.
---! @param a public.eql_v3_text_eq
+--! @brief Operator wrapper for public.{{prefix}}_text_eq.
+--! @param a public.{{prefix}}_text_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_eq.
+--! @brief Operator wrapper for public.{{prefix}}_text_eq.
 --! @param a jsonb
---! @param b public.eql_v3_text_eq
+--! @param b public.{{prefix}}_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text)
-RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$
+--! @return public.{{prefix}}_text_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_eq, selector text)
+RETURNS public.{{prefix}}_text_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer)
-RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$
+--! @return public.{{prefix}}_text_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_eq, selector integer)
+RETURNS public.{{prefix}}_text_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_eq right operand of the blocked operator
---! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq)
-RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$
+--! @param selector public.{{prefix}}_text_eq right operand of the blocked operator
+--! @return public.{{prefix}}_text_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_eq)
+RETURNS public.{{prefix}}_text_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_text_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_text_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_eq_operators.sql b/packages/eql/src/v3/scalars/text/text_eq_operators.sql
index b58d0ade5..de57e0ae8 100644
--- a/packages/eql/src/v3/scalars/text/text_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/text/text_eq_functions.sql
 
 --! @file encrypted_domain/text/text_eq_operators.sql
---! @brief Operators for public.eql_v3_text_eq.
+--! @brief Operators for public.{{prefix}}_text_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq
 );
diff --git a/packages/eql/src/v3/scalars/text/text_functions.sql b/packages/eql/src/v3/scalars/text/text_functions.sql
index 6a4e06dae..e6047c1fa 100644
--- a/packages/eql/src/v3/scalars/text/text_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/text/text_functions.sql
---! @brief Functions for public.eql_v3_text.
+--! @brief Functions for public.{{prefix}}_text.
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text)
-RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$
+--! @return public.{{prefix}}_text never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text, selector text)
+RETURNS public.{{prefix}}_text IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer)
-RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$
+--! @return public.{{prefix}}_text never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text, selector integer)
+RETURNS public.{{prefix}}_text IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text right operand of the blocked operator
---! @return public.eql_v3_text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text)
-RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$
+--! @param selector public.{{prefix}}_text right operand of the blocked operator
+--! @return public.{{prefix}}_text never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text)
+RETURNS public.{{prefix}}_text IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text right operand of the blocked operator
+--! @param selector public.{{prefix}}_text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text, b public.{{prefix}}_text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text left operand of the blocked operator
+--! @param a public.{{prefix}}_text left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text right operand of the blocked operator
+--! @param b public.{{prefix}}_text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_match_functions.sql b/packages/eql/src/v3/scalars/text/text_match_functions.sql
index 9005ad5ba..a89752611 100644
--- a/packages/eql/src/v3/scalars/text/text_match_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_match_functions.sql
@@ -5,652 +5,652 @@
 -- REQUIRE: src/v3/sem/bloom_filter/functions.sql
 
 --! @file encrypted_domain/text/text_match_functions.sql
---! @brief Functions for public.eql_v3_text_match.
+--! @brief Functions for public.{{prefix}}_text_match.
 
---! @brief Index extractor for public.eql_v3_text_match.
---! @param a public.eql_v3_text_match
---! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)
-RETURNS eql_v3_internal.bloom_filter
+--! @brief Index extractor for public.{{prefix}}_text_match.
+--! @param a public.{{prefix}}_text_match
+--! @return {{prefix}}_internal.bloom_filter
+CREATE FUNCTION {{prefix}}.match_term(a public.{{prefix}}_text_match)
+RETURNS {{prefix}}_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_match never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text)
-RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$
+--! @return public.{{prefix}}_text_match never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_match, selector text)
+RETURNS public.{{prefix}}_text_match IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_match never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer)
-RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$
+--! @return public.{{prefix}}_text_match never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_match, selector integer)
+RETURNS public.{{prefix}}_text_match IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_match right operand of the blocked operator
---! @return public.eql_v3_text_match never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match)
-RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$
+--! @param selector public.{{prefix}}_text_match right operand of the blocked operator
+--! @return public.{{prefix}}_text_match never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_match)
+RETURNS public.{{prefix}}_text_match IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_match, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_match, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_match right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_match right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_match)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_match, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_match, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_match, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_match, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_text_match.
---! @param a public.eql_v3_text_match
---! @param b public.eql_v3_text_match
+--! @brief Operator wrapper for public.{{prefix}}_text_match.
+--! @param a public.{{prefix}}_text_match
+--! @param b public.{{prefix}}_text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_match.
---! @param a public.eql_v3_text_match
+--! @brief Operator wrapper for public.{{prefix}}_text_match.
+--! @param a public.{{prefix}}_text_match
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_match, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b::public.{{prefix}}_text_match) AND (cardinality({{prefix}}.match_term(b::public.{{prefix}}_text_match)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_match.
+--! @brief Operator wrapper for public.{{prefix}}_text_match.
 --! @param a jsonb
---! @param b public.eql_v3_text_match
+--! @param b public.{{prefix}}_text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}.matches(a jsonb, b public.{{prefix}}_text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a::public.{{prefix}}_text_match) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a::public.{{prefix}}_text_match)) = 0) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_match, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_match, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_match, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_match, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_match, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_match, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_match, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_match left operand of the blocked operator
+--! @param a public.{{prefix}}_text_match left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_match, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_match.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_match.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_match right operand of the blocked operator
+--! @param b public.{{prefix}}_text_match right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_match)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_match'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_match_operators.sql b/packages/eql/src/v3/scalars/text/text_match_operators.sql
index 8f8bae19c..3a8bd4553 100644
--- a/packages/eql/src/v3/scalars/text/text_match_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_match_operators.sql
@@ -4,242 +4,242 @@
 -- REQUIRE: src/v3/scalars/text/text_match_functions.sql
 
 --! @file encrypted_domain/text/text_match_operators.sql
---! @brief Operators for public.eql_v3_text_match.
+--! @brief Operators for public.{{prefix}}_text_match.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match
 );
diff --git a/packages/eql/src/v3/scalars/text/text_operators.sql b/packages/eql/src/v3/scalars/text/text_operators.sql
index 73c967969..649d86b9e 100644
--- a/packages/eql/src/v3/scalars/text/text_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/text/text_functions.sql
 
 --! @file encrypted_domain/text/text_operators.sql
---! @brief Operators for public.eql_v3_text.
+--! @brief Operators for public.{{prefix}}_text.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text
 );
diff --git a/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql b/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql
index b73708a46..996be49d3 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_operators.sql
 
 --! @file encrypted_domain/text/text_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_text_ord.
+--! @brief Aggregates for public.{{prefix}}_text_ord.
 
---! @brief State function for min on public.eql_v3_text_ord.
---! @param state public.eql_v3_text_ord
---! @param value public.eql_v3_text_ord
---! @return public.eql_v3_text_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)
-RETURNS public.eql_v3_text_ord
+--! @brief State function for min on public.{{prefix}}_text_ord.
+--! @param state public.{{prefix}}_text_ord
+--! @param value public.{{prefix}}_text_ord
+--! @return public.{{prefix}}_text_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_ord, value public.{{prefix}}_text_ord)
+RETURNS public.{{prefix}}_text_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_text_ord.
---! @param input public.eql_v3_text_ord
---! @return public.eql_v3_text_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_text_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_text_ord.
+--! @param input public.{{prefix}}_text_ord
+--! @return public.{{prefix}}_text_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_text_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_text_ord.
---! @param state public.eql_v3_text_ord
---! @param value public.eql_v3_text_ord
---! @return public.eql_v3_text_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)
-RETURNS public.eql_v3_text_ord
+--! @brief State function for max on public.{{prefix}}_text_ord.
+--! @param state public.{{prefix}}_text_ord
+--! @param value public.{{prefix}}_text_ord
+--! @return public.{{prefix}}_text_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_ord, value public.{{prefix}}_text_ord)
+RETURNS public.{{prefix}}_text_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_text_ord.
---! @param input public.eql_v3_text_ord
---! @return public.eql_v3_text_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_text_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_text_ord.
+--! @param input public.{{prefix}}_text_ord
+--! @return public.{{prefix}}_text_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_text_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/text/text_ord_functions.sql b/packages/eql/src/v3/scalars/text/text_ord_functions.sql
index b8257790c..afd8d5e8c 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_functions.sql
@@ -6,570 +6,570 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/text/text_ord_functions.sql
---! @brief Functions for public.eql_v3_text_ord.
+--! @brief Functions for public.{{prefix}}_text_ord.
 
---! @brief Index extractor for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_ord)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_text_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
---! @param b public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
---! @param a public.eql_v3_text_ord
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
+--! @param a public.{{prefix}}_text_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord
+--! @param b public.{{prefix}}_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text)
-RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$
+--! @return public.{{prefix}}_text_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord, selector text)
+RETURNS public.{{prefix}}_text_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer)
-RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$
+--! @return public.{{prefix}}_text_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord, selector integer)
+RETURNS public.{{prefix}}_text_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_ord right operand of the blocked operator
---! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord)
-RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$
+--! @param selector public.{{prefix}}_text_ord right operand of the blocked operator
+--! @return public.{{prefix}}_text_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_ord)
+RETURNS public.{{prefix}}_text_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql
index 1508bbb48..c7e436d00 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_ope_operators.sql
 
 --! @file encrypted_domain/text/text_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_text_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_text_ord_ope.
 
---! @brief State function for min on public.eql_v3_text_ord_ope.
---! @param state public.eql_v3_text_ord_ope
---! @param value public.eql_v3_text_ord_ope
---! @return public.eql_v3_text_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)
-RETURNS public.eql_v3_text_ord_ope
+--! @brief State function for min on public.{{prefix}}_text_ord_ope.
+--! @param state public.{{prefix}}_text_ord_ope
+--! @param value public.{{prefix}}_text_ord_ope
+--! @return public.{{prefix}}_text_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_ord_ope, value public.{{prefix}}_text_ord_ope)
+RETURNS public.{{prefix}}_text_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_text_ord_ope.
---! @param input public.eql_v3_text_ord_ope
---! @return public.eql_v3_text_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_text_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_text_ord_ope.
+--! @param input public.{{prefix}}_text_ord_ope
+--! @return public.{{prefix}}_text_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_text_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_text_ord_ope.
---! @param state public.eql_v3_text_ord_ope
---! @param value public.eql_v3_text_ord_ope
---! @return public.eql_v3_text_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)
-RETURNS public.eql_v3_text_ord_ope
+--! @brief State function for max on public.{{prefix}}_text_ord_ope.
+--! @param state public.{{prefix}}_text_ord_ope
+--! @param value public.{{prefix}}_text_ord_ope
+--! @return public.{{prefix}}_text_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_ord_ope, value public.{{prefix}}_text_ord_ope)
+RETURNS public.{{prefix}}_text_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_text_ord_ope.
---! @param input public.eql_v3_text_ord_ope
---! @return public.eql_v3_text_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_text_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_text_ord_ope.
+--! @param input public.{{prefix}}_text_ord_ope
+--! @return public.{{prefix}}_text_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_text_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql b/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql
index a2b05930f..6a3566036 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql
@@ -6,570 +6,570 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/text/text_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_text_ord_ope.
+--! @brief Functions for public.{{prefix}}_text_ord_ope.
 
---! @brief Index extractor for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_ord_ope)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_text_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ope) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ope) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
---! @param b public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
---! @param a public.eql_v3_text_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
+--! @param a public.{{prefix}}_text_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ope
+--! @param b public.{{prefix}}_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text)
-RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$
+--! @return public.{{prefix}}_text_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ope, selector text)
+RETURNS public.{{prefix}}_text_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer)
-RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$
+--! @return public.{{prefix}}_text_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ope, selector integer)
+RETURNS public.{{prefix}}_text_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator
---! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope)
-RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_text_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_text_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_ord_ope)
+RETURNS public.{{prefix}}_text_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql b/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql
index 90609b417..cba59dbf4 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_ope_functions.sql
 
 --! @file encrypted_domain/text/text_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_text_ord_ope.
+--! @brief Operators for public.{{prefix}}_text_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/text/text_ord_operators.sql b/packages/eql/src/v3/scalars/text/text_ord_operators.sql
index bbfceaeec..b371ea398 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_functions.sql
 
 --! @file encrypted_domain/text/text_ord_operators.sql
---! @brief Operators for public.eql_v3_text_ord.
+--! @brief Operators for public.{{prefix}}_text_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord
 );
diff --git a/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql
index cf4628582..be2e574b8 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_ore_operators.sql
 
 --! @file encrypted_domain/text/text_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_text_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_text_ord_ore.
 
---! @brief State function for min on public.eql_v3_text_ord_ore.
---! @param state public.eql_v3_text_ord_ore
---! @param value public.eql_v3_text_ord_ore
---! @return public.eql_v3_text_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)
-RETURNS public.eql_v3_text_ord_ore
+--! @brief State function for min on public.{{prefix}}_text_ord_ore.
+--! @param state public.{{prefix}}_text_ord_ore
+--! @param value public.{{prefix}}_text_ord_ore
+--! @return public.{{prefix}}_text_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_ord_ore, value public.{{prefix}}_text_ord_ore)
+RETURNS public.{{prefix}}_text_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_text_ord_ore.
---! @param input public.eql_v3_text_ord_ore
---! @return public.eql_v3_text_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_text_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_text_ord_ore.
+--! @param input public.{{prefix}}_text_ord_ore
+--! @return public.{{prefix}}_text_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_text_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_text_ord_ore.
---! @param state public.eql_v3_text_ord_ore
---! @param value public.eql_v3_text_ord_ore
---! @return public.eql_v3_text_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)
-RETURNS public.eql_v3_text_ord_ore
+--! @brief State function for max on public.{{prefix}}_text_ord_ore.
+--! @param state public.{{prefix}}_text_ord_ore
+--! @param value public.{{prefix}}_text_ord_ore
+--! @return public.{{prefix}}_text_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_ord_ore, value public.{{prefix}}_text_ord_ore)
+RETURNS public.{{prefix}}_text_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_text_ord_ore.
---! @param input public.eql_v3_text_ord_ore
---! @return public.eql_v3_text_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_text_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_text_ord_ore.
+--! @param input public.{{prefix}}_text_ord_ore
+--! @return public.{{prefix}}_text_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_text_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql b/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql
index f0bae2ed9..d61d16612 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql
@@ -7,570 +7,570 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/text/text_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_text_ord_ore.
+--! @brief Functions for public.{{prefix}}_text_ord_ore.
 
---! @brief Index extractor for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_ord_ore)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_text_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ore) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ore) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
---! @param b public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
---! @param a public.eql_v3_text_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
+--! @param a public.{{prefix}}_text_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_ord_ore
+--! @param b public.{{prefix}}_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text)
-RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$
+--! @return public.{{prefix}}_text_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ore, selector text)
+RETURNS public.{{prefix}}_text_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer)
-RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$
+--! @return public.{{prefix}}_text_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ore, selector integer)
+RETURNS public.{{prefix}}_text_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator
---! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore)
-RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_text_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_text_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_ord_ore)
+RETURNS public.{{prefix}}_text_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql b/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql
index bead4d0c1..4a4a9d957 100644
--- a/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/text/text_ord_ore_functions.sql
 
 --! @file encrypted_domain/text/text_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_text_ord_ore.
+--! @brief Operators for public.{{prefix}}_text_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/text/text_search_aggregates.sql b/packages/eql/src/v3/scalars/text/text_search_aggregates.sql
index cd7377420..eb105ee61 100644
--- a/packages/eql/src/v3/scalars/text/text_search_aggregates.sql
+++ b/packages/eql/src/v3/scalars/text/text_search_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/text/text_search_operators.sql
 
 --! @file encrypted_domain/text/text_search_aggregates.sql
---! @brief Aggregates for public.eql_v3_text_search.
+--! @brief Aggregates for public.{{prefix}}_text_search.
 
---! @brief State function for min on public.eql_v3_text_search.
---! @param state public.eql_v3_text_search
---! @param value public.eql_v3_text_search
---! @return public.eql_v3_text_search
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)
-RETURNS public.eql_v3_text_search
+--! @brief State function for min on public.{{prefix}}_text_search.
+--! @param state public.{{prefix}}_text_search
+--! @param value public.{{prefix}}_text_search
+--! @return public.{{prefix}}_text_search
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_search, value public.{{prefix}}_text_search)
+RETURNS public.{{prefix}}_text_search
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_text_search.
---! @param input public.eql_v3_text_search
---! @return public.eql_v3_text_search
-CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_text_search,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_text_search.
+--! @param input public.{{prefix}}_text_search
+--! @return public.{{prefix}}_text_search
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_search) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_text_search,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_text_search.
---! @param state public.eql_v3_text_search
---! @param value public.eql_v3_text_search
---! @return public.eql_v3_text_search
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)
-RETURNS public.eql_v3_text_search
+--! @brief State function for max on public.{{prefix}}_text_search.
+--! @param state public.{{prefix}}_text_search
+--! @param value public.{{prefix}}_text_search
+--! @return public.{{prefix}}_text_search
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_search, value public.{{prefix}}_text_search)
+RETURNS public.{{prefix}}_text_search
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_text_search.
---! @param input public.eql_v3_text_search
---! @return public.eql_v3_text_search
-CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_text_search,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_text_search.
+--! @param input public.{{prefix}}_text_search
+--! @return public.{{prefix}}_text_search
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_search) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_text_search,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/text/text_search_functions.sql b/packages/eql/src/v3/scalars/text/text_search_functions.sql
index b4cf3f5d2..22dfe9043 100644
--- a/packages/eql/src/v3/scalars/text/text_search_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_search_functions.sql
@@ -7,560 +7,560 @@
 -- REQUIRE: src/v3/sem/bloom_filter/functions.sql
 
 --! @file encrypted_domain/text/text_search_functions.sql
---! @brief Functions for public.eql_v3_text_search.
+--! @brief Functions for public.{{prefix}}_text_search.
 
---! @brief Index extractor for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_search)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_text_search)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)
-RETURNS eql_v3_internal.bloom_filter
+--! @brief Index extractor for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @return {{prefix}}_internal.bloom_filter
+CREATE FUNCTION {{prefix}}.match_term(a public.{{prefix}}_text_search)
+RETURNS {{prefix}}_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_search) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_search) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
---! @param b public.eql_v3_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_search right operand of the blocked operator
+--! @param b public.{{prefix}}_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
---! @param b public.eql_v3_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_search right operand of the blocked operator
+--! @param b public.{{prefix}}_text_search right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_search never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text)
-RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$
+--! @return public.{{prefix}}_text_search never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search, selector text)
+RETURNS public.{{prefix}}_text_search IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_search never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer)
-RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$
+--! @return public.{{prefix}}_text_search never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search, selector integer)
+RETURNS public.{{prefix}}_text_search IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_search right operand of the blocked operator
---! @return public.eql_v3_text_search never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search)
-RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$
+--! @param selector public.{{prefix}}_text_search right operand of the blocked operator
+--! @return public.{{prefix}}_text_search never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_search)
+RETURNS public.{{prefix}}_text_search IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_search right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_search right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_search)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_search, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_search, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_search, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_search, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
---! @param b public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
---! @param a public.eql_v3_text_search
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
+--! @param a public.{{prefix}}_text_search
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b::public.{{prefix}}_text_search) AND (cardinality({{prefix}}.match_term(b::public.{{prefix}}_text_search)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search.
+--! @brief Operator wrapper for public.{{prefix}}_text_search.
 --! @param a jsonb
---! @param b public.eql_v3_text_search
+--! @param b public.{{prefix}}_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}.matches(a jsonb, b public.{{prefix}}_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a::public.{{prefix}}_text_search) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a::public.{{prefix}}_text_search)) = 0) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_search, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_search, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_search, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_search, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
---! @param b public.eql_v3_text_search right operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
+--! @param b public.{{prefix}}_text_search right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_search right operand of the blocked operator
+--! @param b public.{{prefix}}_text_search right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_search)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_search_operators.sql b/packages/eql/src/v3/scalars/text/text_search_operators.sql
index 68181488c..e335cfc71 100644
--- a/packages/eql/src/v3/scalars/text/text_search_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_search_operators.sql
@@ -4,260 +4,260 @@
 -- REQUIRE: src/v3/scalars/text/text_search_functions.sql
 
 --! @file encrypted_domain/text/text_search_operators.sql
---! @brief Operators for public.eql_v3_text_search.
+--! @brief Operators for public.{{prefix}}_text_search.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search
 );
diff --git a/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql b/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql
index 5204b2f58..0f67b6f9f 100644
--- a/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/text/text_search_ore_operators.sql
 
 --! @file encrypted_domain/text/text_search_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_text_search_ore.
+--! @brief Aggregates for public.{{prefix}}_text_search_ore.
 
---! @brief State function for min on public.eql_v3_text_search_ore.
---! @param state public.eql_v3_text_search_ore
---! @param value public.eql_v3_text_search_ore
---! @return public.eql_v3_text_search_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)
-RETURNS public.eql_v3_text_search_ore
+--! @brief State function for min on public.{{prefix}}_text_search_ore.
+--! @param state public.{{prefix}}_text_search_ore
+--! @param value public.{{prefix}}_text_search_ore
+--! @return public.{{prefix}}_text_search_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_search_ore, value public.{{prefix}}_text_search_ore)
+RETURNS public.{{prefix}}_text_search_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_text_search_ore.
---! @param input public.eql_v3_text_search_ore
---! @return public.eql_v3_text_search_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_text_search_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_text_search_ore.
+--! @param input public.{{prefix}}_text_search_ore
+--! @return public.{{prefix}}_text_search_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_search_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_text_search_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_text_search_ore.
---! @param state public.eql_v3_text_search_ore
---! @param value public.eql_v3_text_search_ore
---! @return public.eql_v3_text_search_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)
-RETURNS public.eql_v3_text_search_ore
+--! @brief State function for max on public.{{prefix}}_text_search_ore.
+--! @param state public.{{prefix}}_text_search_ore
+--! @param value public.{{prefix}}_text_search_ore
+--! @return public.{{prefix}}_text_search_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_search_ore, value public.{{prefix}}_text_search_ore)
+RETURNS public.{{prefix}}_text_search_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_text_search_ore.
---! @param input public.eql_v3_text_search_ore
---! @return public.eql_v3_text_search_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_text_search_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_text_search_ore.
+--! @param input public.{{prefix}}_text_search_ore
+--! @return public.{{prefix}}_text_search_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_search_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_text_search_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql b/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql
index 60f75a5ed..fb3eaa35d 100644
--- a/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql
@@ -8,560 +8,560 @@
 -- REQUIRE: src/v3/sem/bloom_filter/functions.sql
 
 --! @file encrypted_domain/text/text_search_ore_functions.sql
---! @brief Functions for public.eql_v3_text_search_ore.
+--! @brief Functions for public.{{prefix}}_text_search_ore.
 
---! @brief Index extractor for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_search_ore)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_text_search_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Index extractor for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)
-RETURNS eql_v3_internal.bloom_filter
+--! @brief Index extractor for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @return {{prefix}}_internal.bloom_filter
+CREATE FUNCTION {{prefix}}.match_term(a public.{{prefix}}_text_search_ore)
+RETURNS {{prefix}}_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_search_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search_ore) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_search_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search_ore) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
---! @param b public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
---! @param b public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text)
-RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$
+--! @return public.{{prefix}}_text_search_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search_ore, selector text)
+RETURNS public.{{prefix}}_text_search_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer)
-RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$
+--! @return public.{{prefix}}_text_search_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search_ore, selector integer)
+RETURNS public.{{prefix}}_text_search_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_search_ore right operand of the blocked operator
---! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore)
-RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$
+--! @param selector public.{{prefix}}_text_search_ore right operand of the blocked operator
+--! @return public.{{prefix}}_text_search_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_search_ore)
+RETURNS public.{{prefix}}_text_search_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_search_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_search_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_search_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_search_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_search_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
---! @param b public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
---! @param a public.eql_v3_text_search_ore
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
+--! @param a public.{{prefix}}_text_search_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b::public.{{prefix}}_text_search_ore) AND (cardinality({{prefix}}.match_term(b::public.{{prefix}}_text_search_ore)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$;
 
---! @brief Operator wrapper for public.eql_v3_text_search_ore.
+--! @brief Operator wrapper for public.{{prefix}}_text_search_ore.
 --! @param a jsonb
---! @param b public.eql_v3_text_search_ore
+--! @param b public.{{prefix}}_text_search_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}.matches(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE
-AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;
+AS $$ SELECT {{prefix}}.match_term(a::public.{{prefix}}_text_search_ore) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a::public.{{prefix}}_text_search_ore)) = 0) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_search_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_search_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_search_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_search_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
---! @param b public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_text_search_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_text_search_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_search_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql b/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql
index b1980cc7d..a8d35616d 100644
--- a/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql
@@ -4,260 +4,260 @@
 -- REQUIRE: src/v3/scalars/text/text_search_ore_functions.sql
 
 --! @file encrypted_domain/text/text_search_ore_operators.sql
---! @brief Operators for public.eql_v3_text_search_ore.
+--! @brief Operators for public.{{prefix}}_text_search_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3.matches,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,
+  FUNCTION = {{prefix}}.matches,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore,
   RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore
 );
diff --git a/packages/eql/src/v3/scalars/text/text_types.sql b/packages/eql/src/v3/scalars/text/text_types.sql
index 28f2718bb..c4c93d202 100644
--- a/packages/eql/src/v3/scalars/text/text_types.sql
+++ b/packages/eql/src/v3/scalars/text/text_types.sql
@@ -6,65 +6,65 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_text.
+  --! @brief Encrypted domain public.{{prefix}}_text.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_text IS 'EQL encrypted text (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_text_eq.
+  --! @brief Encrypted domain public.{{prefix}}_text_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_eq IS 'EQL encrypted text (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_text_match.
+  --! @brief Encrypted domain public.{{prefix}}_text_match.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_match' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_match AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_match AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'bf'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_match IS 'EQL encrypted text (matching)';
 
-  --! @brief Encrypted domain public.eql_v3_text_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_text_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -74,18 +74,18 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_ord_ore IS 'EQL encrypted text (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_text_ord.
+  --! @brief Encrypted domain public.{{prefix}}_text_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -93,18 +93,18 @@ BEGIN
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_ord IS 'EQL encrypted text (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_text_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_text_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -112,18 +112,18 @@ BEGIN
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_ord_ope IS 'EQL encrypted text (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_text_search_ore.
+  --! @brief Encrypted domain public.{{prefix}}_text_search_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_search_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_search_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -134,18 +134,18 @@ BEGIN
         AND VALUE ? 'bf'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';
 
-  --! @brief Encrypted domain public.eql_v3_text_search.
+  --! @brief Encrypted domain public.{{prefix}}_text_search.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_text_search' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_text_search AS jsonb
+    CREATE DOMAIN public.{{prefix}}_text_search AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -154,10 +154,10 @@ BEGIN
         AND VALUE ? 'hm'
         AND VALUE ? 'op'
         AND VALUE ? 'bf'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';
+  COMMENT ON DOMAIN public.{{prefix}}_text_search IS 'EQL encrypted text (equality, ordering, matching)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql
index 56f32c95a..69d61924d 100644
--- a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql
@@ -5,340 +5,340 @@
 -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
 
 --! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql
---! @brief Functions for public.eql_v3_json_entry.
+--! @brief Functions for public.{{prefix}}_json_entry.
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_json_entry left operand of the blocked operator
---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_json_entry left operand of the blocked operator
+--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_json_entry.
+--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_json_entry right operand of the blocked operator
+--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_json_entry right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)
+CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql
index 2da514109..99c06b37e 100644
--- a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql
@@ -5,124 +5,124 @@
 -- REQUIRE: src/v3/scalars/timestamp/json_entry_timestamp_functions.sql
 
 --! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql
---! @brief Operators for public.eql_v3_json_entry.
+--! @brief Operators for public.{{prefix}}_json_entry.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
index 9bee74f0d..9adbce317 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
@@ -4,44 +4,44 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql
---! @brief Functions for eql_v3.query_timestamp_eq.
+--! @brief Functions for {{prefix}}.query_timestamp_eq.
 
---! @brief Index extractor for eql_v3.query_timestamp_eq.
---! @param a eql_v3.query_timestamp_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for {{prefix}}.query_timestamp_eq.
+--! @param a {{prefix}}.query_timestamp_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_timestamp_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
---! @param b eql_v3.query_timestamp_eq
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
+--! @param b {{prefix}}.query_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_eq, b {{prefix}}.query_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_eq.
---! @param a eql_v3.query_timestamp_eq
---! @param b public.eql_v3_timestamp_eq
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq.
+--! @param a {{prefix}}.query_timestamp_eq
+--! @param b public.{{prefix}}_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
---! @param b eql_v3.query_timestamp_eq
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
+--! @param b {{prefix}}.query_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_eq, b {{prefix}}.query_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_eq.
---! @param a eql_v3.query_timestamp_eq
---! @param b public.eql_v3_timestamp_eq
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq.
+--! @param a {{prefix}}.query_timestamp_eq
+--! @param b public.{{prefix}}_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql
index 59115cfd1..da1d3981f 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql
@@ -4,28 +4,28 @@
 -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql
---! @brief Operators for eql_v3.query_timestamp_eq.
+--! @brief Operators for {{prefix}}.query_timestamp_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = {{prefix}}.query_timestamp_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = {{prefix}}.query_timestamp_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
index 4fbc3c5a8..fb15aea1c 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql
---! @brief Functions for eql_v3.query_timestamp_ord.
+--! @brief Functions for {{prefix}}.query_timestamp_ord.
 
---! @brief Index extractor for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_timestamp_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b eql_v3.query_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b {{prefix}}.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b eql_v3.query_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b {{prefix}}.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b eql_v3.query_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b {{prefix}}.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b eql_v3.query_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b {{prefix}}.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b eql_v3.query_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b {{prefix}}.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b eql_v3.query_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b {{prefix}}.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord.
---! @param a eql_v3.query_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord.
+--! @param a {{prefix}}.query_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
index 9570cfaa7..a6073f700 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql
---! @brief Functions for eql_v3.query_timestamp_ord_ope.
+--! @brief Functions for {{prefix}}.query_timestamp_ord_ope.
 
---! @brief Index extractor for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_timestamp_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b eql_v3.query_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b {{prefix}}.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b eql_v3.query_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b {{prefix}}.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b eql_v3.query_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b {{prefix}}.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b eql_v3.query_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b {{prefix}}.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b eql_v3.query_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b {{prefix}}.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b eql_v3.query_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b {{prefix}}.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
---! @param a eql_v3.query_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope.
+--! @param a {{prefix}}.query_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql
index bea80edde..5bd5cdd90 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql
---! @brief Operators for eql_v3.query_timestamp_ord_ope.
+--! @brief Operators for {{prefix}}.query_timestamp_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql
index e8aba6361..303def929 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql
---! @brief Operators for eql_v3.query_timestamp_ord.
+--! @brief Operators for {{prefix}}.query_timestamp_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
index 41c697170..b081475a3 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
@@ -4,108 +4,108 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql
---! @brief Functions for eql_v3.query_timestamp_ord_ore.
+--! @brief Functions for {{prefix}}.query_timestamp_ord_ore.
 
---! @brief Index extractor for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_timestamp_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b eql_v3.query_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b {{prefix}}.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b eql_v3.query_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b {{prefix}}.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b eql_v3.query_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b {{prefix}}.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b eql_v3.query_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b {{prefix}}.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b eql_v3.query_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b {{prefix}}.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b eql_v3.query_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b {{prefix}}.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
---! @param a eql_v3.query_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore.
+--! @param a {{prefix}}.query_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql
index 63a7acda9..13b0cecd9 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql
@@ -4,76 +4,76 @@
 -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
 
 --! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql
---! @brief Operators for eql_v3.query_timestamp_ord_ore.
+--! @brief Operators for {{prefix}}.query_timestamp_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql
index 741e38141..4a9978ee0 100644
--- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql
+++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql
@@ -3,41 +3,41 @@
 
 --! @file v3/scalars/timestamp/query_timestamp_types.sql
 --! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).
---! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are
 --!       never valid column types, so they don't belong in the column-type
 --!       namespace, and dropping the EQL-owned schema can never drop an
 --!       application column.
 --! @note Cast a query operand explicitly to its `query_` domain in a predicate
---!       (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,
+--!       (e.g. `WHERE col = $1::{{prefix}}.query_timestamp_eq`). A bare,
 --!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_timestamp_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_timestamp_eq' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb
+    CREATE DOMAIN {{prefix}}.query_timestamp_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'hm'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';
+  COMMENT ON DOMAIN {{prefix}}.query_timestamp_eq IS 'EQL timestamp query operand (equality)';
 
-  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_timestamp_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb
+    CREATE DOMAIN {{prefix}}.query_timestamp_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,46 +46,46 @@ BEGIN
         AND NOT (VALUE ? 'c')
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_timestamp_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_timestamp_ord' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb
+    CREATE DOMAIN {{prefix}}.query_timestamp_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';
 
-  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).
+  --! @brief Query-operand domain {{prefix}}.query_timestamp_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
+    WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace
   ) THEN
-    CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb
+    CREATE DOMAIN {{prefix}}.query_timestamp_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'op'
         AND NOT (VALUE ? 'c')
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';
+  COMMENT ON DOMAIN {{prefix}}.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql
index c5551cfc4..9ffb046cd 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql
@@ -5,634 +5,634 @@
 -- REQUIRE: src/v3/sem/hmac_256/functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_eq_functions.sql
---! @brief Functions for public.eql_v3_timestamp_eq.
+--! @brief Functions for public.{{prefix}}_timestamp_eq.
 
---! @brief Index extractor for public.eql_v3_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)
-RETURNS eql_v3_internal.hmac_256
+--! @brief Index extractor for public.{{prefix}}_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
+--! @return {{prefix}}_internal.hmac_256
+CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_timestamp_eq)
+RETURNS {{prefix}}_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
---! @param b public.eql_v3_timestamp_eq
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
+--! @param b public.{{prefix}}_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_timestamp_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_eq.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_eq
+--! @param b public.{{prefix}}_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_timestamp_eq) = {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
---! @param b public.eql_v3_timestamp_eq
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
+--! @param b public.{{prefix}}_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_eq.
---! @param a public.eql_v3_timestamp_eq
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq.
+--! @param a public.{{prefix}}_timestamp_eq
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;
+AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_timestamp_eq) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_eq.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_eq
+--! @param b public.{{prefix}}_timestamp_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;
+AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_timestamp_eq) <> {{prefix}}.eq_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text)
-RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$
+--! @return public.{{prefix}}_timestamp_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_eq, selector text)
+RETURNS public.{{prefix}}_timestamp_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer)
-RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$
+--! @return public.{{prefix}}_timestamp_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_eq, selector integer)
+RETURNS public.{{prefix}}_timestamp_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator
---! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq)
-RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$
+--! @param selector public.{{prefix}}_timestamp_eq right operand of the blocked operator
+--! @return public.{{prefix}}_timestamp_eq never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_eq)
+RETURNS public.{{prefix}}_timestamp_eq IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_eq, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_eq, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param selector public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_eq)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_eq, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_eq, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_eq, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_eq, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_eq, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_eq, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_eq, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_eq, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_eq)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_eq'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql
index f9c344077..def560a45 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql
@@ -4,245 +4,245 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_eq_operators.sql
---! @brief Operators for public.eql_v3_timestamp_eq.
+--! @brief Operators for public.{{prefix}}_timestamp_eq.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql
index 032d60210..81be42ad0 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql
@@ -4,662 +4,662 @@
 -- REQUIRE: src/v3/scalars/functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_functions.sql
---! @brief Functions for public.eql_v3_timestamp.
+--! @brief Functions for public.{{prefix}}_timestamp.
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text)
-RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$
+--! @return public.{{prefix}}_timestamp never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp, selector text)
+RETURNS public.{{prefix}}_timestamp IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer)
-RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$
+--! @return public.{{prefix}}_timestamp never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp, selector integer)
+RETURNS public.{{prefix}}_timestamp IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp right operand of the blocked operator
---! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp)
-RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$
+--! @param selector public.{{prefix}}_timestamp right operand of the blocked operator
+--! @return public.{{prefix}}_timestamp never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp)
+RETURNS public.{{prefix}}_timestamp IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp right operand of the blocked operator
+--! @param selector public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql
index c634ecaa9..5d2be2118 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql
@@ -4,239 +4,239 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_operators.sql
---! @brief Operators for public.eql_v3_timestamp.
+--! @brief Operators for public.{{prefix}}_timestamp.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3_internal.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3_internal.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3_internal.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3_internal.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3_internal.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3_internal.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql
index 4c35aabf1..18676a280 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_operators.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql
---! @brief Aggregates for public.eql_v3_timestamp_ord.
+--! @brief Aggregates for public.{{prefix}}_timestamp_ord.
 
---! @brief State function for min on public.eql_v3_timestamp_ord.
---! @param state public.eql_v3_timestamp_ord
---! @param value public.eql_v3_timestamp_ord
---! @return public.eql_v3_timestamp_ord
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)
-RETURNS public.eql_v3_timestamp_ord
+--! @brief State function for min on public.{{prefix}}_timestamp_ord.
+--! @param state public.{{prefix}}_timestamp_ord
+--! @param value public.{{prefix}}_timestamp_ord
+--! @return public.{{prefix}}_timestamp_ord
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_timestamp_ord, value public.{{prefix}}_timestamp_ord)
+RETURNS public.{{prefix}}_timestamp_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_timestamp_ord.
---! @param input public.eql_v3_timestamp_ord
---! @return public.eql_v3_timestamp_ord
-CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_timestamp_ord,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_timestamp_ord.
+--! @param input public.{{prefix}}_timestamp_ord
+--! @return public.{{prefix}}_timestamp_ord
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_timestamp_ord) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_timestamp_ord,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_timestamp_ord.
---! @param state public.eql_v3_timestamp_ord
---! @param value public.eql_v3_timestamp_ord
---! @return public.eql_v3_timestamp_ord
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)
-RETURNS public.eql_v3_timestamp_ord
+--! @brief State function for max on public.{{prefix}}_timestamp_ord.
+--! @param state public.{{prefix}}_timestamp_ord
+--! @param value public.{{prefix}}_timestamp_ord
+--! @return public.{{prefix}}_timestamp_ord
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_timestamp_ord, value public.{{prefix}}_timestamp_ord)
+RETURNS public.{{prefix}}_timestamp_ord
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_timestamp_ord.
---! @param input public.eql_v3_timestamp_ord
---! @return public.eql_v3_timestamp_ord
-CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_timestamp_ord,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_timestamp_ord.
+--! @param input public.{{prefix}}_timestamp_ord
+--! @return public.{{prefix}}_timestamp_ord
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_timestamp_ord) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_timestamp_ord,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql
index 0835181df..d912cf0b9 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_functions.sql
---! @brief Functions for public.eql_v3_timestamp_ord.
+--! @brief Functions for public.{{prefix}}_timestamp_ord.
 
---! @brief Index extractor for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_timestamp_ord)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
---! @param b public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
---! @param a public.eql_v3_timestamp_ord
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
+--! @param a public.{{prefix}}_timestamp_ord
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord
+--! @param b public.{{prefix}}_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text)
-RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$
+--! @return public.{{prefix}}_timestamp_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord, selector text)
+RETURNS public.{{prefix}}_timestamp_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer)
-RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$
+--! @return public.{{prefix}}_timestamp_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord, selector integer)
+RETURNS public.{{prefix}}_timestamp_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord)
-RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$
+--! @param selector public.{{prefix}}_timestamp_ord right operand of the blocked operator
+--! @return public.{{prefix}}_timestamp_ord never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_ord)
+RETURNS public.{{prefix}}_timestamp_ord IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param selector public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_ord)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_ord, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_ord, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_ord, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_ord, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_ord)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql
index 3f2e47eba..216e101af 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql
---! @brief Aggregates for public.eql_v3_timestamp_ord_ope.
+--! @brief Aggregates for public.{{prefix}}_timestamp_ord_ope.
 
---! @brief State function for min on public.eql_v3_timestamp_ord_ope.
---! @param state public.eql_v3_timestamp_ord_ope
---! @param value public.eql_v3_timestamp_ord_ope
---! @return public.eql_v3_timestamp_ord_ope
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)
-RETURNS public.eql_v3_timestamp_ord_ope
+--! @brief State function for min on public.{{prefix}}_timestamp_ord_ope.
+--! @param state public.{{prefix}}_timestamp_ord_ope
+--! @param value public.{{prefix}}_timestamp_ord_ope
+--! @return public.{{prefix}}_timestamp_ord_ope
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_timestamp_ord_ope, value public.{{prefix}}_timestamp_ord_ope)
+RETURNS public.{{prefix}}_timestamp_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_timestamp_ord_ope.
---! @param input public.eql_v3_timestamp_ord_ope
---! @return public.eql_v3_timestamp_ord_ope
-CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_timestamp_ord_ope,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_timestamp_ord_ope.
+--! @param input public.{{prefix}}_timestamp_ord_ope
+--! @return public.{{prefix}}_timestamp_ord_ope
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_timestamp_ord_ope) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_timestamp_ord_ope,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_timestamp_ord_ope.
---! @param state public.eql_v3_timestamp_ord_ope
---! @param value public.eql_v3_timestamp_ord_ope
---! @return public.eql_v3_timestamp_ord_ope
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)
-RETURNS public.eql_v3_timestamp_ord_ope
+--! @brief State function for max on public.{{prefix}}_timestamp_ord_ope.
+--! @param state public.{{prefix}}_timestamp_ord_ope
+--! @param value public.{{prefix}}_timestamp_ord_ope
+--! @return public.{{prefix}}_timestamp_ord_ope
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_timestamp_ord_ope, value public.{{prefix}}_timestamp_ord_ope)
+RETURNS public.{{prefix}}_timestamp_ord_ope
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_timestamp_ord_ope.
---! @param input public.eql_v3_timestamp_ord_ope
---! @return public.eql_v3_timestamp_ord_ope
-CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_timestamp_ord_ope,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_timestamp_ord_ope.
+--! @param input public.{{prefix}}_timestamp_ord_ope
+--! @return public.{{prefix}}_timestamp_ord_ope
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_timestamp_ord_ope) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_timestamp_ord_ope,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql
index fa9a58797..d62552482 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql
@@ -5,562 +5,562 @@
 -- REQUIRE: src/v3/sem/ope_cllw/functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql
---! @brief Functions for public.eql_v3_timestamp_ord_ope.
+--! @brief Functions for public.{{prefix}}_timestamp_ord_ope.
 
---! @brief Index extractor for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)
-RETURNS eql_v3_internal.ope_cllw
+--! @brief Index extractor for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @return {{prefix}}_internal.ope_cllw
+CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_timestamp_ord_ope)
+RETURNS {{prefix}}_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) = {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) <> {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) < {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) <= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) > {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
---! @param b public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
---! @param a public.eql_v3_timestamp_ord_ope
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
+--! @param a public.{{prefix}}_timestamp_ord_ope
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;
+AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ope
+--! @param b public.{{prefix}}_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;
+AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) >= {{prefix}}.ord_term(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text)
-RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$
+--! @return public.{{prefix}}_timestamp_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ope, selector text)
+RETURNS public.{{prefix}}_timestamp_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer)
-RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$
+--! @return public.{{prefix}}_timestamp_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ope, selector integer)
+RETURNS public.{{prefix}}_timestamp_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope)
-RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$
+--! @param selector public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
+--! @return public.{{prefix}}_timestamp_ord_ope never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_ord_ope)
+RETURNS public.{{prefix}}_timestamp_ord_ope IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ope, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ope, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param selector public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_ord_ope)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_ord_ope, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_ord_ope, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ope, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_ord_ope, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ope, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ope, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_ord_ope, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ope, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_ord_ope)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ope'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql
index 476e379c6..615cdbea8 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql
---! @brief Operators for public.eql_v3_timestamp_ord_ope.
+--! @brief Operators for public.{{prefix}}_timestamp_ord_ope.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql
index 0334ca561..02e9da6df 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_operators.sql
---! @brief Operators for public.eql_v3_timestamp_ord.
+--! @brief Operators for public.{{prefix}}_timestamp_ord.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql
index efdfc06b2..014cf2e02 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql
@@ -5,14 +5,14 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql
---! @brief Aggregates for public.eql_v3_timestamp_ord_ore.
+--! @brief Aggregates for public.{{prefix}}_timestamp_ord_ore.
 
---! @brief State function for min on public.eql_v3_timestamp_ord_ore.
---! @param state public.eql_v3_timestamp_ord_ore
---! @param value public.eql_v3_timestamp_ord_ore
---! @return public.eql_v3_timestamp_ord_ore
-CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)
-RETURNS public.eql_v3_timestamp_ord_ore
+--! @brief State function for min on public.{{prefix}}_timestamp_ord_ore.
+--! @param state public.{{prefix}}_timestamp_ord_ore
+--! @param value public.{{prefix}}_timestamp_ord_ore
+--! @return public.{{prefix}}_timestamp_ord_ore
+CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_timestamp_ord_ore, value public.{{prefix}}_timestamp_ord_ore)
+RETURNS public.{{prefix}}_timestamp_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -24,22 +24,22 @@ BEGIN
 END;
 $$;
 
---! @brief min aggregate for public.eql_v3_timestamp_ord_ore.
---! @param input public.eql_v3_timestamp_ord_ore
---! @return public.eql_v3_timestamp_ord_ore
-CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (
-  sfunc = eql_v3_internal.min_sfunc,
-  stype = public.eql_v3_timestamp_ord_ore,
-  combinefunc = eql_v3_internal.min_sfunc,
+--! @brief min aggregate for public.{{prefix}}_timestamp_ord_ore.
+--! @param input public.{{prefix}}_timestamp_ord_ore
+--! @return public.{{prefix}}_timestamp_ord_ore
+CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_timestamp_ord_ore) (
+  sfunc = {{prefix}}_internal.min_sfunc,
+  stype = public.{{prefix}}_timestamp_ord_ore,
+  combinefunc = {{prefix}}_internal.min_sfunc,
   parallel = safe
 );
 
---! @brief State function for max on public.eql_v3_timestamp_ord_ore.
---! @param state public.eql_v3_timestamp_ord_ore
---! @param value public.eql_v3_timestamp_ord_ore
---! @return public.eql_v3_timestamp_ord_ore
-CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)
-RETURNS public.eql_v3_timestamp_ord_ore
+--! @brief State function for max on public.{{prefix}}_timestamp_ord_ore.
+--! @param state public.{{prefix}}_timestamp_ord_ore
+--! @param value public.{{prefix}}_timestamp_ord_ore
+--! @return public.{{prefix}}_timestamp_ord_ore
+CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_timestamp_ord_ore, value public.{{prefix}}_timestamp_ord_ore)
+RETURNS public.{{prefix}}_timestamp_ord_ore
 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
 SET search_path = pg_catalog, extensions, public
 AS $$
@@ -51,12 +51,12 @@ BEGIN
 END;
 $$;
 
---! @brief max aggregate for public.eql_v3_timestamp_ord_ore.
---! @param input public.eql_v3_timestamp_ord_ore
---! @return public.eql_v3_timestamp_ord_ore
-CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (
-  sfunc = eql_v3_internal.max_sfunc,
-  stype = public.eql_v3_timestamp_ord_ore,
-  combinefunc = eql_v3_internal.max_sfunc,
+--! @brief max aggregate for public.{{prefix}}_timestamp_ord_ore.
+--! @param input public.{{prefix}}_timestamp_ord_ore
+--! @return public.{{prefix}}_timestamp_ord_ore
+CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_timestamp_ord_ore) (
+  sfunc = {{prefix}}_internal.max_sfunc,
+  stype = public.{{prefix}}_timestamp_ord_ore,
+  combinefunc = {{prefix}}_internal.max_sfunc,
   parallel = safe
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql
index 8eb73a1da..6a83371f2 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql
@@ -6,562 +6,562 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql
---! @brief Functions for public.eql_v3_timestamp_ord_ore.
+--! @brief Functions for public.{{prefix}}_timestamp_ord_ore.
 
---! @brief Index extractor for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)
-RETURNS eql_v3_internal.ore_block_256
+--! @brief Index extractor for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @return {{prefix}}_internal.ore_block_256
+CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_timestamp_ord_ore)
+RETURNS {{prefix}}_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
+AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) = {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) <> {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) < {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) <= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) > {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
---! @param b public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
---! @param a public.eql_v3_timestamp_ord_ore
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
+--! @param a public.{{prefix}}_timestamp_ord_ore
 --! @param b jsonb
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$;
 
---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.
+--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore.
 --! @param a jsonb
---! @param b public.eql_v3_timestamp_ord_ore
+--! @param b public.{{prefix}}_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;
+AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) >= {{prefix}}.ord_term_ore(b) $$;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text)
-RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$
+--! @return public.{{prefix}}_timestamp_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ore, selector text)
+RETURNS public.{{prefix}}_timestamp_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer)
-RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$
+--! @return public.{{prefix}}_timestamp_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ore, selector integer)
+RETURNS public.{{prefix}}_timestamp_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator
---! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore)
-RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$
+--! @param selector public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
+--! @return public.{{prefix}}_timestamp_ord_ore never returned — the function always raises "operator not supported"
+CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_ord_ore)
+RETURNS public.{{prefix}}_timestamp_ord_ore IMMUTABLE PARALLEL SAFE
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param selector text right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ore, selector text)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param selector integer right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer)
+CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ore, selector integer)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param selector public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_ord_ore)
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_ord_ore, b text)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_ord_ore, b text[])
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b jsonpath right operand of the blocked operator
 --! @return boolean never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath)
+CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ore, b jsonpath)
 RETURNS boolean IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return text never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_ord_ore, b text[])
 RETURNS text IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ore, b text)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b integer right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer)
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ore, b integer)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b text[] right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[])
+CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_ord_ore, b text[])
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator
+--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator
 --! @param b jsonb right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb)
+CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ore, b jsonb)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
 
---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.
+--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore.
 --!
---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;
+--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises;
 --! it never returns a value. The declared signature exists only so the operator
 --! resolves to this blocker instead of a base-type fallback.
 --!
 --! @param a jsonb left operand of the blocked operator
---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator
+--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator
 --! @return jsonb never returned — the function always raises "operator not supported"
-CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore)
+CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_ord_ore)
 RETURNS jsonb IMMUTABLE PARALLEL SAFE
-AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$
+AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ore'; END; $$
 LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql
index b12b343af..cbf75399f 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql
@@ -4,257 +4,257 @@
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql
 
 --! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql
---! @brief Operators for public.eql_v3_timestamp_ord_ore.
+--! @brief Operators for public.{{prefix}}_timestamp_ord_ore.
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
-  FUNCTION = eql_v3.eq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.eq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
-  FUNCTION = eql_v3.neq,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.neq,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
-  FUNCTION = eql_v3.lt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
-  FUNCTION = eql_v3.lte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.lte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
-  FUNCTION = eql_v3.gt,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gt,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
-  FUNCTION = eql_v3.gte,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,
+  FUNCTION = {{prefix}}.gte,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @> (
-  FUNCTION = eql_v3_internal.contains,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal.contains,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR <@ (
-  FUNCTION = eql_v3_internal.contained_by,
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal.contained_by,
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR -> (
-  FUNCTION = eql_v3_internal."->",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal."->",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR ->> (
-  FUNCTION = eql_v3_internal."->>",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal."->>",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR ? (
-  FUNCTION = eql_v3_internal."?",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."?",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR ?| (
-  FUNCTION = eql_v3_internal."?|",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?|",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR ?& (
-  FUNCTION = eql_v3_internal."?&",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."?&",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR @? (
-  FUNCTION = eql_v3_internal."@?",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@?",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR @@ (
-  FUNCTION = eql_v3_internal."@@",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath
+  FUNCTION = {{prefix}}_internal."@@",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonpath
 );
 
 CREATE OPERATOR #> (
-  FUNCTION = eql_v3_internal."#>",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #>> (
-  FUNCTION = eql_v3_internal."#>>",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#>>",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = integer
 );
 
 CREATE OPERATOR - (
-  FUNCTION = eql_v3_internal."-",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR #- (
-  FUNCTION = eql_v3_internal."#-",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]
+  FUNCTION = {{prefix}}_internal."#-",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[]
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb
 );
 
 CREATE OPERATOR || (
-  FUNCTION = eql_v3_internal."||",
-  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore
+  FUNCTION = {{prefix}}_internal."||",
+  LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore
 );
diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql
index e20c626fe..c0d903b1b 100644
--- a/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql
+++ b/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql
@@ -6,47 +6,47 @@
 
 DO $$
 BEGIN
-  --! @brief Encrypted domain public.eql_v3_timestamp.
+  --! @brief Encrypted domain public.{{prefix}}_timestamp.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_timestamp' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_timestamp AS jsonb
+    CREATE DOMAIN public.{{prefix}}_timestamp AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';
+  COMMENT ON DOMAIN public.{{prefix}}_timestamp IS 'EQL encrypted timestamp (storage only)';
 
-  --! @brief Encrypted domain public.eql_v3_timestamp_eq.
+  --! @brief Encrypted domain public.{{prefix}}_timestamp_eq.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_timestamp_eq' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb
+    CREATE DOMAIN public.{{prefix}}_timestamp_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'hm'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';
+  COMMENT ON DOMAIN public.{{prefix}}_timestamp_eq IS 'EQL encrypted timestamp (equality)';
 
-  --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.
+  --! @brief Encrypted domain public.{{prefix}}_timestamp_ord_ore.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb
+    CREATE DOMAIN public.{{prefix}}_timestamp_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -55,46 +55,46 @@ BEGIN
         AND VALUE ? 'ob'
         AND jsonb_typeof(VALUE -> 'ob') = 'array'
         AND jsonb_array_length(VALUE -> 'ob') > 0
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_timestamp_ord.
+  --! @brief Encrypted domain public.{{prefix}}_timestamp_ord.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_timestamp_ord' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb
+    CREATE DOMAIN public.{{prefix}}_timestamp_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';
 
-  --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.
+  --! @brief Encrypted domain public.{{prefix}}_timestamp_ord_ope.
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{prefix}}_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace
   ) THEN
-    CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb
+    CREATE DOMAIN public.{{prefix}}_timestamp_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
         AND VALUE ? 'i'
         AND VALUE ? 'c'
         AND VALUE ? 'op'
-        AND VALUE->>'v' = '3'
+        AND VALUE->>'v' = '{{eql_version}}'
       );
   END IF;
 
-  COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';
+  COMMENT ON DOMAIN public.{{prefix}}_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';
 END
 $$;
diff --git a/packages/eql/src/v3/schema.sql b/packages/eql/src/v3/schema.sql
index 4411f8e9b..d82dad656 100644
--- a/packages/eql/src/v3/schema.sql
+++ b/packages/eql/src/v3/schema.sql
@@ -1,18 +1,18 @@
 --! @file v3/schema.sql
---! @brief EQL v3 schema creation
+--! @brief EQL v{{eql_version}} schema creation
 --!
---! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted
---! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in
---! public so application tables survive EQL schema uninstall. eql_v3 is the
+--! Creates the {{prefix}} and {{prefix}}_internal schemas. User-column encrypted
+--! domains (public.{{prefix}}_integer, public.{{prefix}}_bigint, and future scalar domains) live in
+--! public so application tables survive EQL schema uninstall. {{prefix}} is the
 --! public API for index-term extractors, aggregates, AND the operator-backing
 --! comparison wrappers
 --! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment
 --! helpers). The wrappers are public because they are the function-form
 --! equivalent of every supported operator: platforms without operator support
 --! (Supabase/PostgREST calls functions, not operators) invoke them by name.
---! eql_v3_internal houses INTERNAL implementation objects only: the
+--! {{prefix}}_internal houses INTERNAL implementation objects only: the
 --! searchable-encrypted-metadata (SEM) index-term types
---! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support
+--! ({{prefix}}_internal.hmac_256, {{prefix}}_internal.ore_block_256) and their support
 --! functions, the unsupported-operator blockers (which only raise), and the
 --! aggregate state functions. Together the two schemas are self-contained —
 --! they own every type they need and have no runtime dependency on another EQL
@@ -21,58 +21,58 @@
 --! Drops existing schema if present to support clean reinstallation.
 --!
 --! @warning DROP SCHEMA CASCADE will remove all objects in the schema
---! @note eql_v3 is a new, additional schema for the encrypted-domain families.
+--! @note {{prefix}} is a new, additional schema for the encrypted-domain families.
 --!
 --! @note DESIGN DECISION — EQL never grants permissions automatically. This
---!       installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:
+--!       installer issues no GRANT (or REVOKE) on {{prefix}} or {{prefix}}_internal:
 --!       access is strictly opt-in. A deployment that exposes EQL to
 --!       non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)
---!       must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on
+--!       must explicitly `GRANT USAGE ON SCHEMA {{prefix}}` and `GRANT EXECUTE` on
 --!       the functions it needs. This is intentional least-privilege, not an
---!       oversight — see docs/reference/permissions.md. eql_v3_internal is not
+--!       oversight — see docs/reference/permissions.md. {{prefix}}_internal is not
 --!       part of the public API and normally needs no grant; where a caller
 --!       reaches an internal object indirectly (a public operator/aggregate
 --!       whose backing state-fn/blocker lives there), grant it deliberately.
 
---! @brief Drop existing EQL v3 schema
+--! @brief Drop existing EQL v{{eql_version}} schema
 --! @warning CASCADE will drop all dependent objects
-DROP SCHEMA IF EXISTS eql_v3 CASCADE;
+DROP SCHEMA IF EXISTS {{prefix}} CASCADE;
 
---! @brief Create EQL v3 schema
+--! @brief Create EQL v{{eql_version}} schema
 --! @note Houses the encrypted-domain type families
-CREATE SCHEMA eql_v3;
+CREATE SCHEMA {{prefix}};
 
---! @brief Drop existing EQL v3 internal schema
+--! @brief Drop existing EQL v{{eql_version}} internal schema
 --! @warning CASCADE will drop all dependent objects
-DROP SCHEMA IF EXISTS eql_v3_internal CASCADE;
+DROP SCHEMA IF EXISTS {{prefix}}_internal CASCADE;
 
---! @brief Create EQL v3 internal implementation schema
---! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their
+--! @brief Create EQL v{{eql_version}} internal implementation schema
+--! @note Houses INTERNAL {{prefix}} objects only: SEM index-term TYPES + their
 --!       support/constructor/comparator functions, the unsupported-operator
 --!       blockers (which only raise), the aggregate state functions, and the
---!       SteVec CHECK validators. Kept out of the public `eql_v3` surface so
+--!       SteVec CHECK validators. Kept out of the public `{{prefix}}` surface so
 --!       internal index-term TYPES do not clutter the Supabase Table Builder
 --!       type picker. NOTE: the operator-backing comparison *wrappers* are NOT
---!       here — they are public in `eql_v3` so every operator has a callable
+--!       here — they are public in `{{prefix}}` so every operator has a callable
 --!       function equivalent for platforms without operator support.
-CREATE SCHEMA eql_v3_internal;
-COMMENT ON SCHEMA eql_v3_internal IS
+CREATE SCHEMA {{prefix}}_internal;
+COMMENT ON SCHEMA {{prefix}}_internal IS
   'EQL internal implementation detail; not a public API surface.';
 
---! @brief Schemas owned by the eql_v3 surface
+--! @brief Schemas owned by the {{prefix}} surface
 --!
 --! Single source of truth for tooling that must enumerate every schema this
---! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a
---! future third eql_v3-family schema is one array literal to edit instead of
+--! installer owns (`{{prefix}}.lints()`, `tasks/pin_search_path_v3.sql`), so a
+--! future third {{prefix}}-family schema is one array literal to edit instead of
 --! a hardcoded schema-name predicate repeated at every call site. Keep in
 --! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in
 --! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into
 --! each schema; this drives what tooling scans across both.
 --!
---! @return name[] The schema names eql_v3 owns (public + internal).
-CREATE FUNCTION eql_v3_internal.owned_schemas()
+--! @return name[] The schema names {{prefix}} owns (public + internal).
+CREATE FUNCTION {{prefix}}_internal.owned_schemas()
   RETURNS name[]
   LANGUAGE sql IMMUTABLE PARALLEL SAFE
 AS $$
-  SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]
+  SELECT ARRAY['{{prefix}}', '{{prefix}}_internal']::name[]
 $$;
diff --git a/packages/eql/src/v3/sem/bloom_filter/functions.sql b/packages/eql/src/v3/sem/bloom_filter/functions.sql
index bcee55da4..db4db5202 100644
--- a/packages/eql/src/v3/sem/bloom_filter/functions.sql
+++ b/packages/eql/src/v3/sem/bloom_filter/functions.sql
@@ -2,10 +2,10 @@
 -- REQUIRE: src/v3/sem/bloom_filter/types.sql
 
 --! @file v3/sem/bloom_filter/functions.sql
---! @brief Extractor for the eql_v3 Bloom-filter SEM index term.
+--! @brief Extractor for the {{prefix}} Bloom-filter SEM index term.
 --!
 --! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column
---! overloads are intentionally omitted — the eql_v3 scalar domains extract from
+--! overloads are intentionally omitted — the {{prefix}} scalar domains extract from
 --! the jsonb payload directly via a cast to the domain. (Doc comments
 --! deliberately avoid naming eql_v2 symbols so the self-containment grep stays
 --! clean.)
@@ -15,12 +15,12 @@
 --! @param val jsonb The encrypted payload.
 --! @return boolean True when the `bf` key is present and non-null.
 --!
---! @internal Defined for parity with the eql_v3 SEM index-term predicates
+--! @internal Defined for parity with the {{prefix}} SEM index-term predicates
 --! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by
 --! the extractor below, which gates on value-shape inline, nor by the generated
 --! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept
 --! as the canonical presence test for callers that need one.
-CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)
+CREATE FUNCTION {{prefix}}_internal.has_bloom_filter(val jsonb)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -33,8 +33,8 @@ $$ LANGUAGE plpgsql;
 --! @brief Extract the Bloom-filter index term from a jsonb payload.
 --!
 --! Inlinable single-statement SQL — the planner can fold this into the calling
---! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which
---! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE
+--! query so the functional GIN index built on `{{prefix}}_internal.match_term(col)` (which
+--! calls this) engages structurally. Mirrors `{{prefix}}_internal.hmac_256(jsonb)`: no RAISE
 --! and no pinned `search_path`. Returns NULL when `bf` is absent or present but
 --! not a json array, rather than raising. The `text_match` domain CHECK
 --! guarantees the `bf` *key* is present but not that it is an array, so a
@@ -46,14 +46,14 @@ $$ LANGUAGE plpgsql;
 --! everything), matching set-containment semantics.
 --!
 --! @param val jsonb The encrypted payload.
---! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or
+--! @return {{prefix}}_internal.bloom_filter The `bf` array as a smallint[] domain value, or
 --!   NULL when `bf` is absent or not a json array.
-CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)
-  RETURNS eql_v3_internal.bloom_filter
+CREATE FUNCTION {{prefix}}_internal.bloom_filter(val jsonb)
+  RETURNS {{prefix}}_internal.bloom_filter
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'
-    THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter
+    THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::{{prefix}}_internal.bloom_filter
   END
 $$;
diff --git a/packages/eql/src/v3/sem/bloom_filter/types.sql b/packages/eql/src/v3/sem/bloom_filter/types.sql
index 618181e74..3c89db075 100644
--- a/packages/eql/src/v3/sem/bloom_filter/types.sql
+++ b/packages/eql/src/v3/sem/bloom_filter/types.sql
@@ -1,15 +1,15 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/sem/bloom_filter/types.sql
---! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.
+--! @brief Self-contained {{prefix}} Bloom-filter SEM index-term type.
 
 --! @brief Bloom-filter index term: a bit array stored as smallint[].
 --!
 --! Backs the `matches` fuzzy-match capability (the public `@@` operator /
---! `eql_v3.matches`) on the text match/search domains. The filter is read from
+--! `{{prefix}}.matches`) on the text match/search domains. The filter is read from
 --! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces
 --! to native `smallint[]` array-containment (`@>`) on this domain — inherited
---! through the base type — so a functional GIN index on `eql_v3.match_term(col)`
+--! through the base type — so a functional GIN index on `{{prefix}}.match_term(col)`
 --! engages; this type itself needs no custom operators.
 --!
 --! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the
@@ -18,4 +18,4 @@
 --!   domains now raise. Internally the `@@` wrapper still reduces to the base
 --!   type's `@>` for GIN indexability.
 --! @note Self-contained: references no eql_v2 symbol.
-CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];
+CREATE DOMAIN {{prefix}}_internal.bloom_filter AS smallint[];
diff --git a/packages/eql/src/v3/sem/hmac_256/functions.sql b/packages/eql/src/v3/sem/hmac_256/functions.sql
index 1efb786bb..6724fd532 100644
--- a/packages/eql/src/v3/sem/hmac_256/functions.sql
+++ b/packages/eql/src/v3/sem/hmac_256/functions.sql
@@ -2,10 +2,10 @@
 -- REQUIRE: src/v3/sem/hmac_256/types.sql
 
 --! @file v3/sem/hmac_256/functions.sql
---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).
+--! @brief HMAC-SHA256 index-term extraction from a jsonb payload ({{prefix}} SEM).
 --!
 --! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and
---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar
+--! ste_vec-entry overloads are intentionally omitted — the {{prefix}} scalar
 --! domains extract from the jsonb payload directly via a cast to the domain.
 --! (Doc comments deliberately avoid naming eql_v2 symbols so the
 --! self-containment grep stays clean.)
@@ -13,17 +13,17 @@
 --! @brief Extract HMAC-SHA256 index term from JSONB payload
 --!
 --! Inlinable single-statement SQL — the planner can fold this into the calling
---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`
+--! query so functional hash/btree indexes built on `{{prefix}}_internal.eq_term(col)`
 --! (which calls this) engage structurally.
 --!
 --! @param val jsonb containing encrypted EQL payload
---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent
-CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)
-  RETURNS eql_v3_internal.hmac_256
+--! @return {{prefix}}_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent
+CREATE FUNCTION {{prefix}}_internal.hmac_256(val jsonb)
+  RETURNS {{prefix}}_internal.hmac_256
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT (val ->> 'hm')::eql_v3_internal.hmac_256
+  SELECT (val ->> 'hm')::{{prefix}}_internal.hmac_256
 $$;
 
 
@@ -31,7 +31,7 @@ $$;
 --!
 --! @param val jsonb containing encrypted EQL payload
 --! @return boolean True if 'hm' field is present and non-null
-CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)
+CREATE FUNCTION {{prefix}}_internal.has_hmac_256(val jsonb)
   RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
diff --git a/packages/eql/src/v3/sem/hmac_256/types.sql b/packages/eql/src/v3/sem/hmac_256/types.sql
index eace5c2ed..49aea94fd 100644
--- a/packages/eql/src/v3/sem/hmac_256/types.sql
+++ b/packages/eql/src/v3/sem/hmac_256/types.sql
@@ -1,12 +1,12 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/sem/hmac_256/types.sql
---! @brief HMAC-SHA256 index term type (eql_v3 SEM)
+--! @brief HMAC-SHA256 index term type ({{prefix}} SEM)
 --!
 --! Domain type representing HMAC-SHA256 hash values. Used for exact-match
 --! encrypted searches. The hash is stored in the 'hm' field of encrypted data
---! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is
+--! payloads. Self-contained {{prefix}} copy (design D1/D3); the eql_v2 original is
 --! unchanged.
 --!
 --! @note Transient type used only during query execution.
-CREATE DOMAIN eql_v3_internal.hmac_256 AS text;
+CREATE DOMAIN {{prefix}}_internal.hmac_256 AS text;
diff --git a/packages/eql/src/v3/sem/ope_cllw/functions.sql b/packages/eql/src/v3/sem/ope_cllw/functions.sql
index 05509e761..9d038a2f5 100644
--- a/packages/eql/src/v3/sem/ope_cllw/functions.sql
+++ b/packages/eql/src/v3/sem/ope_cllw/functions.sql
@@ -2,17 +2,17 @@
 -- REQUIRE: src/v3/sem/ope_cllw/types.sql
 
 --! @file v3/sem/ope_cllw/functions.sql
---! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).
+--! @brief CLLW OPE index-term extraction from a jsonb payload ({{prefix}} SEM).
 
 --! @brief Extract CLLW OPE index term from JSONB payload
 --!
 --! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar
---! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.
+--! payload, hex-decoded to the bytea-backed {{prefix}}_internal.ope_cllw domain.
 --!
 --! Inlinable single-statement SQL — the body is a strict expression of the
 --! argument (`->>` and `decode` are both STRICT), so the planner folds this
 --! into the calling query and functional btree indexes built on
---! `eql_v3.ord_term(col)` (which calls this) engage structurally, the
+--! `{{prefix}}.ord_term(col)` (which calls this) engage structurally, the
 --! same way the hmac_256 equality chain does.
 --!
 --! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and
@@ -20,14 +20,14 @@
 --! btree's NULL handling filters those rows from range queries.
 --!
 --! @param val jsonb containing encrypted EQL payload
---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is
+--! @return {{prefix}}_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is
 --!         absent
-CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)
-  RETURNS eql_v3_internal.ope_cllw
+CREATE FUNCTION {{prefix}}_internal.ope_cllw(val jsonb)
+  RETURNS {{prefix}}_internal.ope_cllw
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw
+  SELECT decode(val ->> 'op', 'hex')::{{prefix}}_internal.ope_cllw
 $$;
 
-COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS
+COMMENT ON FUNCTION {{prefix}}_internal.ope_cllw(jsonb) IS
   'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';
diff --git a/packages/eql/src/v3/sem/ope_cllw/types.sql b/packages/eql/src/v3/sem/ope_cllw/types.sql
index 6321969fb..b27c193da 100644
--- a/packages/eql/src/v3/sem/ope_cllw/types.sql
+++ b/packages/eql/src/v3/sem/ope_cllw/types.sql
@@ -1,7 +1,7 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/sem/ope_cllw/types.sql
---! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)
+--! @brief CLLW OPE index term type for scalar range queries ({{prefix}} SEM)
 --!
 --! Domain type representing a CLLW (Copyless Logarithmic Width)
 --! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in
@@ -12,13 +12,13 @@
 --! order-preserving under plain byte comparison, so the domain inherits
 --! bytea's native comparison operators and DEFAULT btree operator class
 --! outright — no hand-written operators, comparator, or operator class (the
---! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole
+--! same pattern as {{prefix}}_internal.hmac_256 over text). That keeps the whole
 --! comparison chain inlinable, so a functional btree index on
---! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`
---! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),
+--! `{{prefix}}.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`
+--! domains' comparison operators. Contrast {{prefix}}_internal.ore_block_256 (`ob`),
 --! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom
 --! N-block protocol.
 --!
 --! @note Transient type used only during query execution.
---! @see eql_v3_internal.ore_block_256
-CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;
+--! @see {{prefix}}_internal.ore_block_256
+CREATE DOMAIN {{prefix}}_internal.ope_cllw AS bytea;
diff --git a/packages/eql/src/v3/sem/ore_block_256/functions.sql b/packages/eql/src/v3/sem/ore_block_256/functions.sql
index 45f31fdce..1d6108e18 100644
--- a/packages/eql/src/v3/sem/ore_block_256/functions.sql
+++ b/packages/eql/src/v3/sem/ore_block_256/functions.sql
@@ -4,7 +4,7 @@
 -- REQUIRE: src/v3/sem/ore_block_256/types.sql
 
 --! @file v3/sem/ore_block_256/functions.sql
---! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).
+--! @brief ORE block construction, extraction, and comparison ({{prefix}} SEM).
 --!
 --! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The
 --! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array
@@ -16,7 +16,7 @@
 --! @brief Convert JSONB array to ORE block composite type
 --! @internal
 --! @param val jsonb Array of hex-encoded ORE block terms
---! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null
+--! @return {{prefix}}_internal.ore_block_256 ORE block composite, or NULL if input is null
 --! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller
 --!   (`ore_block_256`) is itself plpgsql, so this function is NEVER reached
 --!   from an inlinable context — as `LANGUAGE sql` it paid the per-call
@@ -33,25 +33,25 @@
 --!   drops out of ordered queries). An empty array instead engages the
 --!   comparator's `cardinality = 0` guard, which sorts empty BEFORE every
 --!   non-empty term. See issue #262 (pinned by T7).
-CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)
-RETURNS eql_v3_internal.ore_block_256
+CREATE FUNCTION {{prefix}}_internal.jsonb_array_to_ore_block_256(val jsonb)
+RETURNS {{prefix}}_internal.ore_block_256
   IMMUTABLE
 AS $$
 DECLARE
-  terms eql_v3_internal.ore_block_256_term[];
+  terms {{prefix}}_internal.ore_block_256_term[];
 BEGIN
   IF val IS NULL OR jsonb_typeof(val) != 'array' THEN
     RETURN NULL;
   END IF;
-  SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)
+  SELECT array_agg(ROW(b)::{{prefix}}_internal.ore_block_256_term)
     INTO terms
-  FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;
+  FROM unnest({{prefix}}_internal.jsonb_array_to_bytea_array(val)) AS b;
   -- plpgsql pitfall: `SELECT <composite> INTO <composite-var>` assigns the
   -- select-list columns FIELD-WISE into the variable — return the row
   -- constructor directly instead. The COALESCE stays load-bearing for the
   -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and
   -- the comparator needs an EMPTY terms array, not NULL terms.
-  RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;
+  RETURN ROW(COALESCE(terms, ARRAY[]::{{prefix}}_internal.ore_block_256_term[]))::{{prefix}}_internal.ore_block_256;
 END;
 $$ LANGUAGE plpgsql;
 
@@ -62,24 +62,24 @@ $$ LANGUAGE plpgsql;
 --! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the
 --! structural skip in tasks/pin_search_path_v3.sql does not recognise it;
 --! this marker is the documented manual opt-in.
-COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS
+COMMENT ON FUNCTION {{prefix}}_internal.jsonb_array_to_ore_block_256(jsonb) IS
   'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';
 
 
 --! @brief Extract ORE block index term from JSONB payload
 --! @param val jsonb containing encrypted EQL payload
---! @return eql_v3_internal.ore_block_256 ORE block index term
+--! @return {{prefix}}_internal.ore_block_256 ORE block index term
 --! @throws Exception if 'ob' field is missing
-CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)
-  RETURNS eql_v3_internal.ore_block_256
+CREATE FUNCTION {{prefix}}_internal.ore_block_256(val jsonb)
+  RETURNS {{prefix}}_internal.ore_block_256
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
 AS $$
   BEGIN
     -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without
     -- entering the body, so no explicit `val IS NULL` guard is needed.
-    IF eql_v3_internal.has_ore_block_256(val) THEN
-      RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');
+    IF {{prefix}}_internal.has_ore_block_256(val) THEN
+      RETURN {{prefix}}_internal.jsonb_array_to_ore_block_256(val->'ob');
     END IF;
     RAISE 'Expected an ore index (ob) value in json: %', val;
   END;
@@ -97,7 +97,7 @@ $$ LANGUAGE plpgsql;
 --!   previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so
 --!   reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null)
 --!   both remain `false`.
-CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)
+CREATE FUNCTION {{prefix}}_internal.has_ore_block_256(val jsonb)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
   SET search_path = pg_catalog, extensions, public
@@ -110,8 +110,8 @@ $$ LANGUAGE plpgsql;
 
 --! @brief Compare two ORE block terms using cryptographic comparison
 --! @internal
---! @param a eql_v3_internal.ore_block_256_term First ORE term
---! @param b eql_v3_internal.ore_block_256_term Second ORE term
+--! @param a {{prefix}}_internal.ore_block_256_term First ORE term
+--! @param b {{prefix}}_internal.ore_block_256_term Second ORE term
 --! @return integer -1 if a < b, 0 if a = b, 1 if a > b
 --! @throws Exception if ciphertexts are different lengths
 --! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`
@@ -121,7 +121,7 @@ $$ LANGUAGE plpgsql;
 --!   is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the
 --!   planner fold/cache these in ordering and index contexts. NOT `STRICT`:
 --!   the NULL-handling branches below are load-bearing for the array overload.
-CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)
+CREATE FUNCTION {{prefix}}_internal.compare_ore_block_256_term(a {{prefix}}_internal.ore_block_256_term, b {{prefix}}_internal.ore_block_256_term)
   RETURNS integer
   IMMUTABLE
   SET search_path = pg_catalog, extensions, public
@@ -221,10 +221,10 @@ $$ LANGUAGE plpgsql;
 
 --! @brief Compare arrays of ORE block terms recursively
 --! @internal
---! @param a eql_v3_internal.ore_block_256_term[] First array
---! @param b eql_v3_internal.ore_block_256_term[] Second array
+--! @param a {{prefix}}_internal.ore_block_256_term[] First array
+--! @param b {{prefix}}_internal.ore_block_256_term[] Second array
 --! @return integer -1/0/1, or NULL if either array is NULL
-CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])
+CREATE FUNCTION {{prefix}}_internal.compare_ore_block_256_terms(a {{prefix}}_internal.ore_block_256_term[], b {{prefix}}_internal.ore_block_256_term[])
 RETURNS integer
   IMMUTABLE
   SET search_path = pg_catalog, extensions, public
@@ -248,10 +248,10 @@ AS $$
       RETURN 1;
     END IF;
 
-    cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);
+    cmp_result := {{prefix}}_internal.compare_ore_block_256_term(a[1], b[1]);
 
     IF cmp_result = 0 THEN
-      RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);
+      RETURN {{prefix}}_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);
     END IF;
 
     RETURN cmp_result;
@@ -261,15 +261,15 @@ $$ LANGUAGE plpgsql;
 
 --! @brief Compare ORE block composite types
 --! @internal
---! @param a eql_v3_internal.ore_block_256 First ORE block
---! @param b eql_v3_internal.ore_block_256 Second ORE block
+--! @param a {{prefix}}_internal.ore_block_256 First ORE block
+--! @param b {{prefix}}_internal.ore_block_256 Second ORE block
 --! @return integer -1/0/1
-CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+CREATE FUNCTION {{prefix}}_internal.compare_ore_block_256_terms(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS integer
   IMMUTABLE
   SET search_path = pg_catalog, extensions, public
 AS $$
   BEGIN
-    RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);
+    RETURN {{prefix}}_internal.compare_ore_block_256_terms(a.terms, b.terms);
   END
 $$ LANGUAGE plpgsql;
diff --git a/packages/eql/src/v3/sem/ore_block_256/operator_class.sql b/packages/eql/src/v3/sem/ore_block_256/operator_class.sql
index 7e56ad383..b889c5cd9 100644
--- a/packages/eql/src/v3/sem/ore_block_256/operator_class.sql
+++ b/packages/eql/src/v3/sem/ore_block_256/operator_class.sql
@@ -4,10 +4,10 @@
 -- REQUIRE: src/v3/sem/ore_block_256/operators.sql
 
 --! @file v3/sem/ore_block_256/operator_class.sql
---! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.
+--! @brief B-tree operator family + default class on {{prefix}}_internal.ore_block_256.
 --!
 --! Gives the composite type its DEFAULT btree opclass so the recommended
---! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without
+--! functional index `CREATE INDEX ON t ({{prefix}}.ord_term_ore(col))` engages without
 --! an explicit opclass annotation (design D4).
 --!
 --! @note Creating an operator family/class requires superuser: Postgres forbids
@@ -16,32 +16,32 @@
 --!       the installer as a non-superuser role, so the DO block below ATTEMPTS
 --!       the creation and skips it on insufficient_privilege (SQLSTATE 42501),
 --!       letting the single installer run everywhere. When the class is absent,
---!       ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,
+--!       ORE ordered scans over {{prefix}}_internal.ore_block_256 are unavailable,
 --!       but the order-preserving (OPE) ordering domains — whose extractor
 --!       return types carry a native btree opclass — still index without it. On
 --!       superuser installs (self-managed Postgres, the SQLx test matrix) the
 --!       class is created normally. Any non-privilege error still propagates.
---! @see eql_v3_internal.compare_ore_block_256_terms
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
 
 DO $do$
 BEGIN
-  EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';
+  EXECUTE 'CREATE OPERATOR FAMILY {{prefix}}_internal.ore_block_256_operator_family USING btree';
 
   EXECUTE $ddl$
-    CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class
-      DEFAULT FOR TYPE eql_v3_internal.ore_block_256
-      USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS
+    CREATE OPERATOR CLASS {{prefix}}_internal.ore_block_256_operator_class
+      DEFAULT FOR TYPE {{prefix}}_internal.ore_block_256
+      USING btree FAMILY {{prefix}}_internal.ore_block_256_operator_family AS
         OPERATOR 1 public.<,
         OPERATOR 2 public.<=,
         OPERATOR 3 public.=,
         OPERATOR 4 public.>=,
         OPERATOR 5 public.>,
-        FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+        FUNCTION 1 {{prefix}}_internal.compare_ore_block_256_terms(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
   $ddl$;
 
-  RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';
+  RAISE NOTICE 'EQL: created btree operator class {{prefix}}_internal.ore_block_256_operator_class';
 EXCEPTION
   WHEN insufficient_privilege THEN
-    RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';
+    RAISE NOTICE 'EQL: skipped operator class {{prefix}}_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';
 END;
 $do$;
diff --git a/packages/eql/src/v3/sem/ore_block_256/operators.sql b/packages/eql/src/v3/sem/ore_block_256/operators.sql
index 7b8b2caac..cdd4c9df3 100644
--- a/packages/eql/src/v3/sem/ore_block_256/operators.sql
+++ b/packages/eql/src/v3/sem/ore_block_256/operators.sql
@@ -3,105 +3,105 @@
 -- REQUIRE: src/v3/sem/ore_block_256/functions.sql
 
 --! @file v3/sem/ore_block_256/operators.sql
---! @brief Comparison operators on eql_v3_internal.ore_block_256.
+--! @brief Comparison operators on {{prefix}}_internal.ore_block_256.
 --!
 --! The six backing functions are inlinable single-statement SQL so the planner
---! can fold the eql_v3 comparison wrappers through to functional-index matching.
+--! can fold the {{prefix}} comparison wrappers through to functional-index matching.
 
 --! @brief Equality backing function for ORE block types
 --! @internal
 --!
---! @param a eql_v3_internal.ore_block_256 Left operand
---! @param b eql_v3_internal.ore_block_256 Right operand
+--! @param a {{prefix}}_internal.ore_block_256 Left operand
+--! @param b {{prefix}}_internal.ore_block_256 Right operand
 --! @return boolean True if the ORE blocks are equal
 --!
---! @see eql_v3_internal.compare_ore_block_256_terms
-CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
+CREATE FUNCTION {{prefix}}_internal.ore_block_256_eq(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0
+  SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) = 0
 $$;
 
 --! @brief Not-equal backing function for ORE block types
 --! @internal
 --!
---! @param a eql_v3_internal.ore_block_256 Left operand
---! @param b eql_v3_internal.ore_block_256 Right operand
+--! @param a {{prefix}}_internal.ore_block_256 Left operand
+--! @param b {{prefix}}_internal.ore_block_256 Right operand
 --! @return boolean True if the ORE blocks are not equal
 --!
---! @see eql_v3_internal.compare_ore_block_256_terms
-CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
+CREATE FUNCTION {{prefix}}_internal.ore_block_256_neq(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0
+  SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) <> 0
 $$;
 
 --! @brief Less-than backing function for ORE block types
 --! @internal
 --!
---! @param a eql_v3_internal.ore_block_256 Left operand
---! @param b eql_v3_internal.ore_block_256 Right operand
+--! @param a {{prefix}}_internal.ore_block_256 Left operand
+--! @param b {{prefix}}_internal.ore_block_256 Right operand
 --! @return boolean True if the left operand is less than the right operand
 --!
---! @see eql_v3_internal.compare_ore_block_256_terms
-CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
+CREATE FUNCTION {{prefix}}_internal.ore_block_256_lt(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1
+  SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) = -1
 $$;
 
 --! @brief Less-than-or-equal backing function for ORE block types
 --! @internal
 --!
---! @param a eql_v3_internal.ore_block_256 Left operand
---! @param b eql_v3_internal.ore_block_256 Right operand
+--! @param a {{prefix}}_internal.ore_block_256 Left operand
+--! @param b {{prefix}}_internal.ore_block_256 Right operand
 --! @return boolean True if the left operand is less than or equal to the right operand
 --!
---! @see eql_v3_internal.compare_ore_block_256_terms
-CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
+CREATE FUNCTION {{prefix}}_internal.ore_block_256_lte(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1
+  SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) != 1
 $$;
 
 --! @brief Greater-than backing function for ORE block types
 --! @internal
 --!
---! @param a eql_v3_internal.ore_block_256 Left operand
---! @param b eql_v3_internal.ore_block_256 Right operand
+--! @param a {{prefix}}_internal.ore_block_256 Left operand
+--! @param b {{prefix}}_internal.ore_block_256 Right operand
 --! @return boolean True if the left operand is greater than the right operand
 --!
---! @see eql_v3_internal.compare_ore_block_256_terms
-CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
+CREATE FUNCTION {{prefix}}_internal.ore_block_256_gt(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1
+  SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) = 1
 $$;
 
 --! @brief Greater-than-or-equal backing function for ORE block types
 --! @internal
 --!
---! @param a eql_v3_internal.ore_block_256 Left operand
---! @param b eql_v3_internal.ore_block_256 Right operand
+--! @param a {{prefix}}_internal.ore_block_256 Left operand
+--! @param b {{prefix}}_internal.ore_block_256 Right operand
 --! @return boolean True if the left operand is greater than or equal to the right operand
 --!
---! @see eql_v3_internal.compare_ore_block_256_terms
-CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)
+--! @see {{prefix}}_internal.compare_ore_block_256_terms
+CREATE FUNCTION {{prefix}}_internal.ore_block_256_gte(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256)
 RETURNS boolean
   LANGUAGE sql
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1
+  SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) != -1
 $$;
 
 
@@ -110,11 +110,11 @@ $$;
 --! COMMUTATOR is the operator itself: equality is symmetric. Required for the
 --! MERGES flag — without it the planner raises "could not find commutator" the
 --! first time an ore_block equality is used as a join qual (e.g. via the inlined
---! eql_v3_internal.<T>_ord_ore equality wrappers).
+--! {{prefix}}_internal.<T>_ord_ore equality wrappers).
 CREATE OPERATOR public.= (
-  FUNCTION=eql_v3_internal.ore_block_256_eq,
-  LEFTARG=eql_v3_internal.ore_block_256,
-  RIGHTARG=eql_v3_internal.ore_block_256,
+  FUNCTION={{prefix}}_internal.ore_block_256_eq,
+  LEFTARG={{prefix}}_internal.ore_block_256,
+  RIGHTARG={{prefix}}_internal.ore_block_256,
   COMMUTATOR = OPERATOR(public.=),
   NEGATOR = OPERATOR(public.<>),
   RESTRICT = eqsel,
@@ -125,9 +125,9 @@ CREATE OPERATOR public.= (
 
 --! @brief <> operator for ORE block types
 CREATE OPERATOR public.<> (
-  FUNCTION=eql_v3_internal.ore_block_256_neq,
-  LEFTARG=eql_v3_internal.ore_block_256,
-  RIGHTARG=eql_v3_internal.ore_block_256,
+  FUNCTION={{prefix}}_internal.ore_block_256_neq,
+  LEFTARG={{prefix}}_internal.ore_block_256,
+  RIGHTARG={{prefix}}_internal.ore_block_256,
   COMMUTATOR = OPERATOR(public.<>),
   NEGATOR = OPERATOR(public.=),
   RESTRICT = neqsel,
@@ -137,9 +137,9 @@ CREATE OPERATOR public.<> (
 
 --! @brief > operator for ORE block types
 CREATE OPERATOR public.> (
-  FUNCTION=eql_v3_internal.ore_block_256_gt,
-  LEFTARG=eql_v3_internal.ore_block_256,
-  RIGHTARG=eql_v3_internal.ore_block_256,
+  FUNCTION={{prefix}}_internal.ore_block_256_gt,
+  LEFTARG={{prefix}}_internal.ore_block_256,
+  RIGHTARG={{prefix}}_internal.ore_block_256,
   COMMUTATOR = OPERATOR(public.<),
   NEGATOR = OPERATOR(public.<=),
   RESTRICT = scalargtsel,
@@ -148,9 +148,9 @@ CREATE OPERATOR public.> (
 
 --! @brief < operator for ORE block types
 CREATE OPERATOR public.< (
-  FUNCTION=eql_v3_internal.ore_block_256_lt,
-  LEFTARG=eql_v3_internal.ore_block_256,
-  RIGHTARG=eql_v3_internal.ore_block_256,
+  FUNCTION={{prefix}}_internal.ore_block_256_lt,
+  LEFTARG={{prefix}}_internal.ore_block_256,
+  RIGHTARG={{prefix}}_internal.ore_block_256,
   COMMUTATOR = OPERATOR(public.>),
   NEGATOR = OPERATOR(public.>=),
   RESTRICT = scalarltsel,
@@ -159,9 +159,9 @@ CREATE OPERATOR public.< (
 
 --! @brief <= operator for ORE block types
 CREATE OPERATOR public.<= (
-  FUNCTION=eql_v3_internal.ore_block_256_lte,
-  LEFTARG=eql_v3_internal.ore_block_256,
-  RIGHTARG=eql_v3_internal.ore_block_256,
+  FUNCTION={{prefix}}_internal.ore_block_256_lte,
+  LEFTARG={{prefix}}_internal.ore_block_256,
+  RIGHTARG={{prefix}}_internal.ore_block_256,
   COMMUTATOR = OPERATOR(public.>=),
   NEGATOR = OPERATOR(public.>),
   RESTRICT = scalarlesel,
@@ -170,9 +170,9 @@ CREATE OPERATOR public.<= (
 
 --! @brief >= operator for ORE block types
 CREATE OPERATOR public.>= (
-  FUNCTION=eql_v3_internal.ore_block_256_gte,
-  LEFTARG=eql_v3_internal.ore_block_256,
-  RIGHTARG=eql_v3_internal.ore_block_256,
+  FUNCTION={{prefix}}_internal.ore_block_256_gte,
+  LEFTARG={{prefix}}_internal.ore_block_256,
+  RIGHTARG={{prefix}}_internal.ore_block_256,
   COMMUTATOR = OPERATOR(public.<=),
   NEGATOR = OPERATOR(public.<),
   RESTRICT = scalargesel,
diff --git a/packages/eql/src/v3/sem/ore_block_256/types.sql b/packages/eql/src/v3/sem/ore_block_256/types.sql
index 608610238..b697ddaf6 100644
--- a/packages/eql/src/v3/sem/ore_block_256/types.sql
+++ b/packages/eql/src/v3/sem/ore_block_256/types.sql
@@ -1,16 +1,16 @@
 -- REQUIRE: src/v3/schema.sql
 
 --! @file v3/sem/ore_block_256/types.sql
---! @brief ORE block index-term types (eql_v3 SEM).
+--! @brief ORE block index-term types ({{prefix}} SEM).
 --!
---! Self-contained eql_v3 copies of the Order-Revealing Encryption block types
+--! Self-contained {{prefix}} copies of the Order-Revealing Encryption block types
 --! (design D1/D3). The eql_v2 originals are unchanged.
 
 --! @brief ORE block term type for Order-Revealing Encryption
 --!
 --! Composite type representing a single ORE block term. Stores encrypted data
 --! as bytea that enables range comparisons without decryption.
-CREATE TYPE eql_v3_internal.ore_block_256_term AS (
+CREATE TYPE {{prefix}}_internal.ore_block_256_term AS (
   bytes bytea
 );
 
@@ -21,6 +21,6 @@ CREATE TYPE eql_v3_internal.ore_block_256_term AS (
 --! in the 'ob' field of encrypted data payloads.
 --!
 --! @note Transient type used only during query execution.
-CREATE TYPE eql_v3_internal.ore_block_256 AS (
-  terms eql_v3_internal.ore_block_256_term[]
+CREATE TYPE {{prefix}}_internal.ore_block_256 AS (
+  terms {{prefix}}_internal.ore_block_256_term[]
 );
diff --git a/packages/eql/src/v3/version.template b/packages/eql/src/v3/version.template
index 828635352..bc546f8a9 100644
--- a/packages/eql/src/v3/version.template
+++ b/packages/eql/src/v3/version.template
@@ -2,10 +2,10 @@
 -- Source is src/v3/version.template
 -- REQUIRE: src/v3/schema.sql
 
-DROP FUNCTION IF EXISTS eql_v3.version();
+DROP FUNCTION IF EXISTS {{prefix}}.version();
 
 --! @file v3/version.sql
---! @brief EQL version reporting (self-contained eql_v3 surface)
+--! @brief EQL version reporting (self-contained {{prefix}} surface)
 --!
 --! This file is auto-generated from src/v3/version.template during build.
 --! The $RELEASE_VERSION placeholder is replaced with the actual release
@@ -21,9 +21,9 @@ DROP FUNCTION IF EXISTS eql_v3.version();
 --!
 --! @note Auto-generated during build from src/v3/version.template
 --!
---! Example: `SELECT eql_v3.version()` returns the installed version string,
+--! Example: `SELECT {{prefix}}.version()` returns the installed version string,
 --! e.g. `'3.0.0'` (or `'DEV'` for development builds).
-CREATE FUNCTION eql_v3.version()
+CREATE FUNCTION {{prefix}}.version()
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -32,6 +32,6 @@ $$ LANGUAGE SQL;
 
 --! @brief Schema-level version marker for obj_description() discoverability
 --!
---! Mirrors eql_v3.version() as a comment on the schema so the installed
---! version can also be read via obj_description('eql_v3'::regnamespace).
-COMMENT ON SCHEMA eql_v3 IS '$RELEASE_VERSION';
+--! Mirrors {{prefix}}.version() as a comment on the schema so the installed
+--! version can also be read via obj_description('{{prefix}}'::regnamespace).
+COMMENT ON SCHEMA {{prefix}} IS '$RELEASE_VERSION';
diff --git a/packages/eql/tasks/build.sh b/packages/eql/tasks/build.sh
index cf8cd28d1..4d20af73a 100755
--- a/packages/eql/tasks/build.sh
+++ b/packages/eql/tasks/build.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 #MISE description="Build SQL into single release file"
 #MISE alias="b"
-#MISE sources=["src/v3/**/*.sql", "src/v3/version.template", "tasks/pin_search_path_v3.sql", "tasks/uninstall-v3.sql", "crates/eql-domains/src/**/*.rs", "crates/eql-codegen/src/**/*.rs", "Cargo.toml", "Cargo.lock", "crates/eql-codegen/Cargo.toml", "crates/eql-domains/Cargo.toml", "tasks/build/ordering.sh", "tasks/test/verify_symbol_order_v3.sh", "tasks/test/verify_installer_complete.sh", "tasks/test/symbol_order_allowlist.txt"]
-#MISE outputs=["release/cipherstash-encrypt.sql","release/cipherstash-encrypt-uninstall.sql","src/deps-ordered-v3.txt"]
+#MISE sources=["src/v3/**/*.sql", "src/v3/version.template", "tasks/pin_search_path_v3.sql", "tasks/uninstall-v3.sql", "crates/eql-domains/src/**/*.rs", "crates/eql-codegen/src/**/*.rs", "crates/eql-codegen/templates/**", "Cargo.toml", "Cargo.lock", "crates/eql-codegen/Cargo.toml", "crates/eql-domains/Cargo.toml", "tasks/build/ordering.sh", "tasks/test/verify_symbol_order_v3.sh", "tasks/test/verify_installer_complete.sh", "tasks/test/symbol_order_allowlist.txt"]
+#MISE outputs=["release/cipherstash-encrypt.sql","release/cipherstash-encrypt-uninstall.sql","src/deps-ordered-v3.txt","build/render/eql_v3/deps-ordered.txt"]
 #USAGE flag "--version <version>" help="Specify release version of EQL" default="DEV"
 
 #!/bin/bash
@@ -80,23 +80,44 @@ sed "s/\$RELEASE_VERSION/$RELEASE_VERSION/g" src/v3/version.template > src/v3/ve
 cargo run -q -p eql-codegen -- order > src/deps-ordered-v3.txt.tmp
 mv src/deps-ordered-v3.txt.tmp src/deps-ordered-v3.txt
 
-bash tasks/test/verify_symbol_order_v3.sh src/deps-ordered-v3.txt
-
-: > release/cipherstash-encrypt.sql
-while IFS= read -r f; do
-  strip_require_lines "$f" >> release/cipherstash-encrypt.sql
-done < src/deps-ordered-v3.txt
-cat tasks/pin_search_path_v3.sql >> release/cipherstash-encrypt.sql
-
-# `eql-codegen order` guarantees the ORDER contains every file on disk. This gate
-# closes the layer below — that the concat loop above actually emitted each ordered
-# file's body. 93 of the ~244 v3 files are leaves (required by nothing, defining
-# nothing another file references), so dropping one yields an installer that applies
-# cleanly and passes the symbol checker while silently shipping less than it should.
-bash tasks/test/verify_installer_complete.sh src/deps-ordered-v3.txt release/cipherstash-encrypt.sql
-
-cat tasks/uninstall-v3.sql >> release/cipherstash-encrypt-uninstall.sql
-
+# The source names its schemas and payload version by placeholder
+# ({{prefix}}, {{eql_version}}; ADR-0002), so it is not installable SQL until it
+# is rendered. Render the ordered files, the pin script and the uninstaller as
+# EQL v3 into build/render/eql_v3/ (same relative paths), then run every gate
+# and assemble the installer from the rendered tree. `eql-codegen render` fails
+# on an unknown placeholder and on a literal eql_v3/eql_v4 in the source, and
+# writes nothing unless every file renders.
+assemble() {
+  local version=$1 installer=$2 uninstaller=$3
+  local root="build/render/eql_v${version}"
+  local ordered="$root/deps-ordered.txt"
+
+  rm -rf "$root"
+  # shellcheck disable=SC2046 # one path per line, none with spaces
+  cargo run -q -p eql-codegen -- render "$version" "$root" \
+    $(cat src/deps-ordered-v3.txt) tasks/pin_search_path_v3.sql tasks/uninstall-v3.sql
+  sed "s|^|$root/|" src/deps-ordered-v3.txt > "$ordered"
+
+  bash tasks/test/verify_symbol_order_v3.sh "$ordered"
+
+  : > "$installer"
+  while IFS= read -r f; do
+    strip_require_lines "$f" >> "$installer"
+  done < "$ordered"
+  cat "$root/tasks/pin_search_path_v3.sql" >> "$installer"
+
+  # `eql-codegen order` guarantees the ORDER contains every file on disk. This
+  # gate closes the layer below — that the concat loop above actually emitted
+  # each ordered file's body. 93 of the ~244 v3 files are leaves (required by
+  # nothing, defining nothing another file references), so dropping one yields
+  # an installer that applies cleanly and passes the symbol checker while
+  # silently shipping less than it should.
+  bash tasks/test/verify_installer_complete.sh "$ordered" "$installer" "$root"
+
+  cat "$root/tasks/uninstall-v3.sql" > "$uninstaller"
+}
+
+assemble 3 release/cipherstash-encrypt.sql release/cipherstash-encrypt-uninstall.sql
 
 echo
 echo '###############################################'
diff --git a/packages/eql/tasks/docs/doxygen-filter.sh b/packages/eql/tasks/docs/doxygen-filter.sh
index fe00c19ab..41ad51c13 100755
--- a/packages/eql/tasks/docs/doxygen-filter.sh
+++ b/packages/eql/tasks/docs/doxygen-filter.sh
@@ -10,8 +10,10 @@ if [ "$#" -ne 1 ]; then
   exit 2
 fi
 
-# Prepares SQL for Doxygen's C++ parser. Four transforms:
+# Prepares SQL for Doxygen's C++ parser. Five transforms:
 #
+#  0. Render the {{prefix}} / {{eql_version}} placeholders (ADR-0002) as EQL v3,
+#     so the reference names `eql_v3.eq_term`, not `{{prefix}}.eq_term`.
 #  1. Omit blocks marked `@cond deprecated_compatibility`. These functions
 #     remain callable for backwards compatibility but must not appear in the
 #     generated function reference or source browser.
@@ -41,7 +43,11 @@ fi
 #
 #     Reducing each to a single `CREATE AGGREGATE name(argtype);` declaration
 #     recovers the name in both cases and leaves a clean argument list.
-awk '
+#
+# A real pipe, not `awk … < <(sed …)`: pipefail covers a pipe, so a `sed` that
+# cannot read its input fails the filter, and docs_v3_grep.sh relies on that
+# status. A process substitution's exit status is lost.
+sed -e 's/{{prefix}}/eql_v3/g' -e 's/{{eql_version}}/3/g' "$1" | awk '
   /^--![[:space:]]+@cond[[:space:]]+deprecated_compatibility[[:space:]]*$/ {
     inhidden = 1
     print ""
@@ -102,4 +108,4 @@ awk '
     gsub(/--/, "//", out)
     print out
   }
-' "$1"
+'
diff --git a/packages/eql/tasks/docs/validate/documented-sql.sh b/packages/eql/tasks/docs/validate/documented-sql.sh
index 9ce3fb348..60d954768 100755
--- a/packages/eql/tasks/docs/validate/documented-sql.sh
+++ b/packages/eql/tasks/docs/validate/documented-sql.sh
@@ -10,7 +10,10 @@ PGPORT=${PGPORT:-7432}
 PGUSER=${PGUSER:-cipherstash}
 PGPASSWORD=${PGPASSWORD:-password}
 PGDATABASE=${PGDATABASE:-postgres}
-source_directory="src"
+# The rendered eql_v3 tree, not src/: the source writes its schemas and payload
+# version as {{prefix}} / {{eql_version}} placeholders (ADR-0002), which psql
+# cannot parse. `mise run build` renders it.
+source_directory="build/render/eql_v3/src"
 
 echo "Validating SQL syntax for all documented files..."
 echo ""
diff --git a/packages/eql/tasks/pin_search_path_v3.sql b/packages/eql/tasks/pin_search_path_v3.sql
index 9718b161b..327fd509c 100644
--- a/packages/eql/tasks/pin_search_path_v3.sql
+++ b/packages/eql/tasks/pin_search_path_v3.sql
@@ -1,11 +1,11 @@
 --! @file pin_search_path_v3.sql
---! @brief Post-install: pin search_path on every eql_v3.* function.
+--! @brief Post-install: pin search_path on every {{prefix}}.* function.
 --!
---! Appended verbatim by `tasks/build.sh` to the end of the v3-only release
+--! Appended verbatim by `tasks/build.sh` to the end of the v{{eql_version}}-only release
 --! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives
 --! outside src/ so it stays out of the dependency graph.
 --!
---! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and
+--! Iterates over functions in the `{{prefix}}` and `{{prefix}}_internal` schemas and
 --! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,
 --! satisfying Supabase splinter's `function_search_path_mutable` lint.
 --!
@@ -32,19 +32,19 @@ BEGIN
     RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';
   END IF;
 
-  -- eql_v3 SEM index-term functions that must stay inlinable for
-  -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause
+  -- {{prefix}} SEM index-term functions that must stay inlinable for
+  -- functional-index matching (no SET, IMMUTABLE). Mirrors the {{prefix}} clause
   -- in the legacy combined pin_search_path.sql.
   SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids
   FROM pg_catalog.pg_proc p
   JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-  WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())
+  WHERE n.nspname = ANY({{prefix}}_internal.owned_schemas())
     AND (
       (p.pronargs = 2
         AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',
                           'ore_block_256_lt', 'ore_block_256_lte',
                           'ore_block_256_gt', 'ore_block_256_gte'))
-      -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a
+      -- The CLLW-OPE surface is the extractor alone: {{prefix}}_internal.ope_cllw is a
       -- domain over bytea (native comparison operators and btree opclass),
       -- so there are no ope-specific comparison functions to keep inlinable.
       OR (p.pronargs = 1
@@ -62,7 +62,7 @@ BEGIN
     SELECT p.oid
     FROM pg_catalog.pg_proc p
     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-    WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())
+    WHERE n.nspname = ANY({{prefix}}_internal.owned_schemas())
       AND p.prokind IN ('f', 'w')
       AND NOT EXISTS (
         SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c
@@ -86,7 +86,7 @@ BEGIN
             AND dt.typbasetype = jsonb_oid
             AND (
               dn.nspname = 'public'
-              OR dn.nspname = ANY(eql_v3_internal.owned_schemas())
+              OR dn.nspname = ANY({{prefix}}_internal.owned_schemas())
             )
         )
       )
diff --git a/packages/eql/tasks/test/docs_v3_grep.sh b/packages/eql/tasks/test/docs_v3_grep.sh
index 14cc27c67..c0f9d149a 100755
--- a/packages/eql/tasks/test/docs_v3_grep.sh
+++ b/packages/eql/tasks/test/docs_v3_grep.sh
@@ -64,7 +64,7 @@ done
 
 # Deprecated SQL compatibility aliases remain installed, but the explicitly
 # hidden block must never reach Doxygen — including its generated source browser.
-ste_vec_alias_count=$(grep -c '^CREATE FUNCTION eql_v3\.ste_vec_contains' src/v3/json/functions.sql || true)
+ste_vec_alias_count=$(grep -c '^CREATE FUNCTION {{prefix}}\.ste_vec_contains' src/v3/json/functions.sql || true)
 if [ "$ste_vec_alias_count" -ne 2 ]; then
   echo "FAIL: expected both deprecated ste_vec_contains overloads in src/v3/json/functions.sql" >&2
   status=1
diff --git a/packages/eql/tasks/test/verify_installer_complete.sh b/packages/eql/tasks/test/verify_installer_complete.sh
index 7f0263ef8..1d8665a67 100755
--- a/packages/eql/tasks/test/verify_installer_complete.sh
+++ b/packages/eql/tasks/test/verify_installer_complete.sh
@@ -24,9 +24,12 @@ set -euo pipefail
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$REPO_ROOT"
 
-ORDERED="${1:-src/deps-ordered-v3.txt}"
+ORDERED="${1:-build/render/eql_v3/deps-ordered.txt}"
 INSTALLER="${2:-release/cipherstash-encrypt.sql}"
-PIN="tasks/pin_search_path_v3.sql"
+# The rendered tree the ordered paths point into (build.sh renders the
+# placeholder source into build/render/eql_v<N>/, keeping relative paths).
+ROOT="${3:-build/render/eql_v3}"
+PIN="$ROOT/tasks/pin_search_path_v3.sql"
 
 for f in "$ORDERED" "$INSTALLER" "$PIN"; do
   if [[ ! -f "$f" ]]; then
@@ -73,7 +76,11 @@ fail=0
 echo "==> Non-vacuity gate: the order names every src/v3 SQL file"
 work="$(mktemp -d)"
 trap 'rm -rf "$work"' EXIT
-find src/v3 -type f -name '*.sql' ! -name '*_test.sql' | LC_ALL=C sort > "$work/disk"
+# The disk side reads the SOURCE tree, not the rendered one: build.sh renders
+# exactly the files the order names, so the rendered tree always agrees with the
+# order and a comparison against it could never fail. Map the source paths into
+# the rendered namespace the order uses.
+find src/v3 -type f -name '*.sql' ! -name '*_test.sql' | sed "s|^|$ROOT/|" | LC_ALL=C sort > "$work/disk"
 grep -v '^[[:space:]]*$' "$ORDERED" | LC_ALL=C sort > "$work/order" || true
 n_disk=$(count_lines "$work/disk")
 
diff --git a/packages/eql/tasks/test/verify_symbol_order_v3.sh b/packages/eql/tasks/test/verify_symbol_order_v3.sh
index 1d859d527..58bfff08f 100755
--- a/packages/eql/tasks/test/verify_symbol_order_v3.sh
+++ b/packages/eql/tasks/test/verify_symbol_order_v3.sh
@@ -56,7 +56,7 @@ set -euo pipefail
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$REPO_ROOT"
 
-ORDERED="${1:-src/deps-ordered-v3.txt}"
+ORDERED="${1:-build/render/eql_v3/deps-ordered.txt}"
 # Overridable so the self-test can exercise the missing-allowlist path without
 # disturbing the committed one.
 ALLOW="${SYMBOL_ORDER_ALLOWLIST:-tasks/test/symbol_order_allowlist.txt}"
diff --git a/packages/eql/tasks/uninstall-v3.sql b/packages/eql/tasks/uninstall-v3.sql
index 7c9dd57f1..d1cfb7248 100644
--- a/packages/eql/tasks/uninstall-v3.sql
+++ b/packages/eql/tasks/uninstall-v3.sql
@@ -1,8 +1,8 @@
--- Uninstall the standalone eql_v3 surface. CASCADE removes the domains, SEM
--- types, operators, opclass, and any columns typed with the eql_v3 domains.
-DROP SCHEMA IF EXISTS eql_v3 CASCADE;
+-- Uninstall the standalone {{prefix}} surface. CASCADE removes the domains, SEM
+-- types, operators, opclass, and any columns typed with the {{prefix}} domains.
+DROP SCHEMA IF EXISTS {{prefix}} CASCADE;
 
--- Drop the internal implementation schema after eql_v3 (eql_v3's extractors and
--- operators depend on eql_v3_internal types; dropping eql_v3 first with CASCADE
--- removes those dependents, then eql_v3_internal drops cleanly).
-DROP SCHEMA IF EXISTS eql_v3_internal CASCADE;
+-- Drop the internal implementation schema after {{prefix}} ({{prefix}}'s extractors and
+-- operators depend on {{prefix}}_internal types; dropping {{prefix}} first with CASCADE
+-- removes those dependents, then {{prefix}}_internal drops cleanly).
+DROP SCHEMA IF EXISTS {{prefix}}_internal CASCADE;