diff --git a/Cargo.lock b/Cargo.lock
index b3e84895a34c8..1ed68b3193b65 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8564,6 +8564,7 @@ dependencies = [
  "serde_json",
  "thiserror",
  "tracing 0.1.30",
+ "value",
  "vector_common",
  "vrl-diagnostic",
  "vrl-parser",
diff --git a/lib/enrichment/src/find_enrichment_table_records.rs b/lib/enrichment/src/find_enrichment_table_records.rs
index c751d5350fba7..5208f5779c8c2 100644
--- a/lib/enrichment/src/find_enrichment_table_records.rs
+++ b/lib/enrichment/src/find_enrichment_table_records.rs
@@ -129,7 +129,7 @@ impl Expression for FindEnrichmentTableRecordsFn {
                     .collect::<std::result::Result<Vec<_>, _>>(),
                 value => Err(value::Error::Expected {
                     got: value.kind(),
-                    expected: Kind::Array,
+                    expected: Kind::array(Collection::any()),
                 }),
             })
             .transpose()?;
@@ -164,9 +164,7 @@ impl Expression for FindEnrichmentTableRecordsFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible()
-            .array_mapped::<(), Kind>(map! { (): Kind::Object })
+        TypeDef::array(Collection::from_unknown(Kind::object(Collection::any()))).fallible()
     }
 }
 
diff --git a/lib/enrichment/src/get_enrichment_table_record.rs b/lib/enrichment/src/get_enrichment_table_record.rs
index 97f459796efd7..cf1dab6da7ffb 100644
--- a/lib/enrichment/src/get_enrichment_table_record.rs
+++ b/lib/enrichment/src/get_enrichment_table_record.rs
@@ -125,7 +125,7 @@ impl Expression for GetEnrichmentTableRecordFn {
                     .collect::<std::result::Result<Vec<_>, _>>(),
                 value => Err(value::Error::Expected {
                     got: value.kind(),
-                    expected: Kind::Array,
+                    expected: Kind::array(Collection::any()),
                 }),
             })
             .transpose()?;
@@ -156,9 +156,7 @@ impl Expression for GetEnrichmentTableRecordFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible()
-            .add_object::<(), Kind>(map! { (): Kind::all() })
+        TypeDef::object(Collection::any()).fallible()
     }
 }
 
diff --git a/lib/lookup/Cargo.toml b/lib/lookup/Cargo.toml
index d528458322dcb..5ba4ff8ab43b8 100644
--- a/lib/lookup/Cargo.toml
+++ b/lib/lookup/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
-serde = { version = "1.0.136", default-features = false, features = ["derive"] }
+serde = { version = "1.0.136", default-features = false, features = ["derive", "alloc"] }
 tracing = { version = "0.1", default-features = false, features = ["attributes"] }
 snafu = { version = "0.7", default-features = false }
 regex = { version = "1.5.4", default-features = false, features = ["std", "perf"] }
diff --git a/lib/value/src/kind/collection.rs b/lib/value/src/kind/collection.rs
index 3ee6f7ec96c19..04607a0884bd9 100644
--- a/lib/value/src/kind/collection.rs
+++ b/lib/value/src/kind/collection.rs
@@ -50,6 +50,15 @@ impl<T: Ord> Collection<T> {
         }
     }
 
+    /// Create a collection kind of which there are no known and no unknown kinds.
+    #[must_use]
+    pub fn empty() -> Self {
+        Self {
+            known: BTreeMap::default(),
+            unknown: None,
+        }
+    }
+
     /// Create a collection kind of which the encapsulated values can be any kind.
     #[must_use]
     pub fn any() -> Self {
diff --git a/lib/vector-vrl-functions/src/get_metadata_field.rs b/lib/vector-vrl-functions/src/get_metadata_field.rs
index dbf7ecf8136f2..8ef2f56297402 100644
--- a/lib/vector-vrl-functions/src/get_metadata_field.rs
+++ b/lib/vector-vrl-functions/src/get_metadata_field.rs
@@ -55,6 +55,6 @@ impl Expression for GetMetadataFieldFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes().add_null()
+        TypeDef::bytes().add_null().infallible()
     }
 }
diff --git a/lib/vector-vrl-functions/src/remove_metadata_field.rs b/lib/vector-vrl-functions/src/remove_metadata_field.rs
index 9e5f9bd8f601f..4cc7ffc0bb19b 100644
--- a/lib/vector-vrl-functions/src/remove_metadata_field.rs
+++ b/lib/vector-vrl-functions/src/remove_metadata_field.rs
@@ -53,6 +53,6 @@ impl Expression for RemoveMetadataFieldFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().null()
+        TypeDef::null().infallible()
     }
 }
diff --git a/lib/vector-vrl-functions/src/set_metadata_field.rs b/lib/vector-vrl-functions/src/set_metadata_field.rs
index bd1eebef4a676..4bcb45cd5539b 100644
--- a/lib/vector-vrl-functions/src/set_metadata_field.rs
+++ b/lib/vector-vrl-functions/src/set_metadata_field.rs
@@ -63,6 +63,6 @@ impl Expression for SetMetadataFieldFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().null()
+        TypeDef::null().infallible()
     }
 }
diff --git a/lib/vrl/compiler/Cargo.toml b/lib/vrl/compiler/Cargo.toml
index 7c00919a59cf3..ab3957cbd9c90 100644
--- a/lib/vrl/compiler/Cargo.toml
+++ b/lib/vrl/compiler/Cargo.toml
@@ -10,6 +10,7 @@ diagnostic = { package = "vrl-diagnostic", path = "../diagnostic" }
 parser = { package = "vrl-parser", path = "../parser" }
 lookup = { path = "../../lookup" }
 vector_common = { path = "../../vector-common", default-features = false, features = ["conversion"] }
+value = { path = "../../value" }
 
 bitflags = "1"
 bytes = "1.1.0"
diff --git a/lib/vrl/compiler/benches/kind.rs b/lib/vrl/compiler/benches/kind.rs
index a31d2d183faac..639b79b119dd9 100644
--- a/lib/vrl/compiler/benches/kind.rs
+++ b/lib/vrl/compiler/benches/kind.rs
@@ -1,17 +1,17 @@
 use std::fmt;
 
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use vrl_compiler::value::Kind;
+use vrl_compiler::value::kind;
 
 struct Parameters {
-    basis: Kind,
+    basis: u16,
 }
 
 static PARAMETERS: [Parameters; 4] = [
-    Parameters { basis: Kind::Bytes },
-    Parameters { basis: Kind::Array },
-    Parameters { basis: Kind::Regex },
-    Parameters { basis: Kind::Null },
+    Parameters { basis: kind::BYTES },
+    Parameters { basis: kind::ARRAY },
+    Parameters { basis: kind::REGEX },
+    Parameters { basis: kind::NULL },
 ];
 
 impl fmt::Display for Parameters {
@@ -23,8 +23,16 @@ impl fmt::Display for Parameters {
 fn benchmark_kind_display(c: &mut Criterion) {
     let mut group = c.benchmark_group("vrl_compiler/value::kind::display");
     for param in &PARAMETERS {
-        group.bench_with_input(BenchmarkId::from_parameter(param), &param, |b, &param| {
-            b.iter(|| format!("{}", param.basis))
+        let parameter = vrl_compiler::Parameter {
+            keyword: "",
+            kind: param.basis,
+            required: false,
+        };
+
+        let kind = parameter.kind();
+
+        group.bench_with_input(BenchmarkId::from_parameter(param), &kind, |b, kind| {
+            b.iter(|| format!("{}", kind))
         });
     }
 }
diff --git a/lib/vrl/compiler/src/expression/abort.rs b/lib/vrl/compiler/src/expression/abort.rs
index 5bd1267358196..440e28f6a257a 100644
--- a/lib/vrl/compiler/src/expression/abort.rs
+++ b/lib/vrl/compiler/src/expression/abort.rs
@@ -32,7 +32,7 @@ impl Abort {
                     })
                 } else if !type_def.is_bytes() {
                     Err(Error {
-                        variant: ErrorVariant::NonString(type_def.kind()),
+                        variant: ErrorVariant::NonString(type_def.into()),
                         expr_span,
                     })
                 } else {
@@ -69,7 +69,7 @@ impl Expression for Abort {
     }
 
     fn type_def(&self, _: &State) -> TypeDef {
-        TypeDef::new().infallible().null()
+        TypeDef::null().infallible()
     }
 
     fn compile_to_vm(&self, vm: &mut crate::vm::Vm) -> Result<(), String> {
@@ -138,7 +138,7 @@ impl DiagnosticError for Error {
     }
 
     fn labels(&self) -> Vec<Label> {
-        match self.variant {
+        match &self.variant {
             ErrorVariant::FallibleExpr => vec![
                 Label::primary(
                     "abort only accepts an infallible expression argument",
diff --git a/lib/vrl/compiler/src/expression/array.rs b/lib/vrl/compiler/src/expression/array.rs
index 110b91c3a4025..0ab57d309415d 100644
--- a/lib/vrl/compiler/src/expression/array.rs
+++ b/lib/vrl/compiler/src/expression/array.rs
@@ -1,4 +1,4 @@
-use std::{fmt, ops::Deref};
+use std::{collections::BTreeMap, fmt, ops::Deref};
 
 use crate::{
     expression::{Expr, Resolved},
@@ -53,7 +53,13 @@ impl Expression for Array {
         // fallible.
         let fallible = type_defs.iter().any(TypeDef::is_fallible);
 
-        TypeDef::new().array(type_defs).with_fallibility(fallible)
+        let collection = type_defs
+            .into_iter()
+            .enumerate()
+            .map(|(index, type_def)| (index.into(), type_def.into()))
+            .collect::<BTreeMap<_, _>>();
+
+        TypeDef::array(collection).with_fallibility(fallible)
     }
 
     fn compile_to_vm(&self, vm: &mut crate::vm::Vm) -> Result<(), String> {
@@ -94,35 +100,37 @@ impl From<Vec<Expr>> for Array {
 
 #[cfg(test)]
 mod tests {
-    use crate::{expr, map, test_type_def, value::Kind, TypeDef};
+    use super::*;
+    use crate::{expr, test_type_def, value::Kind, TypeDef};
+    use value::kind::Collection;
 
     test_type_def![
         empty_array {
             expr: |_| expr!([]),
-            want: TypeDef::new().array::<TypeDef>(vec![]),
+            want: TypeDef::array(Collection::empty()),
         }
 
         scalar_array {
             expr: |_| expr!([1, "foo", true]),
-            want: TypeDef::new().array_mapped::<i32, TypeDef>(map! {
-                0: Kind::Integer,
-                1: Kind::Bytes,
-                2: Kind::Boolean,
-            }),
+            want: TypeDef::array(BTreeMap::from([
+                (0.into(), Kind::integer()),
+                (1.into(), Kind::bytes()),
+                (2.into(), Kind::boolean()),
+            ])),
         }
 
         mixed_array {
             expr: |_| expr!([1, [true, "foo"], { "bar": null }]),
-            want: TypeDef::new().array_mapped::<i32, TypeDef>(map! {
-                0: Kind::Integer,
-                1: TypeDef::new().array_mapped::<i32, TypeDef>(map! {
-                    0: Kind::Boolean,
-                    1: Kind::Bytes,
-                }),
-                2: TypeDef::new().object::<&str, TypeDef>(map! {
-                    "bar": Kind::Null,
-                }),
-            }),
+            want: TypeDef::array(BTreeMap::from([
+                (0.into(), Kind::integer()),
+                (1.into(), Kind::array(BTreeMap::from([
+                    (0.into(), Kind::boolean()),
+                    (1.into(), Kind::bytes()),
+                ]))),
+                (2.into(), Kind::object(BTreeMap::from([
+                    ("bar".into(), Kind::null())
+                ]))),
+            ])),
         }
     ];
 }
diff --git a/lib/vrl/compiler/src/expression/assignment.rs b/lib/vrl/compiler/src/expression/assignment.rs
index ad56634bab0b3..ac2c48a039946 100644
--- a/lib/vrl/compiler/src/expression/assignment.rs
+++ b/lib/vrl/compiler/src/expression/assignment.rs
@@ -9,6 +9,7 @@ use crate::{
         ast::{self, Ident},
         Node,
     },
+    value::kind::DefaultValue,
     vm::OpCode,
     Context, Expression, Span, State, TypeDef, Value,
 };
@@ -108,7 +109,7 @@ impl Assignment {
                 // "err" target.
                 let ok = Target::try_from(ok.into_inner())?;
                 let type_def = type_def.infallible();
-                let default = type_def.kind().default_value();
+                let default_value = type_def.default_value();
                 let value = match &expr {
                     Expr::Literal(v) => Some(v.to_value()),
                     _ => None,
@@ -119,7 +120,7 @@ impl Assignment {
                 // "err" target is assigned `null` or a string containing the
                 // error message.
                 let err = Target::try_from(err.into_inner())?;
-                let type_def = TypeDef::new().bytes().add_null().infallible();
+                let type_def = TypeDef::bytes().add_null().infallible();
 
                 err.insert_type_def(state, type_def, None);
 
@@ -127,7 +128,7 @@ impl Assignment {
                     ok,
                     err,
                     expr: Box::new(expr),
-                    default,
+                    default: default_value,
                 }
             }
         };
@@ -214,7 +215,7 @@ impl Target {
             Internal(ident, path) => {
                 let td = match path {
                     None => type_def,
-                    Some(path) => type_def.for_path(path.clone()),
+                    Some(path) => type_def.for_path(&path.to_lookup()),
                 };
 
                 let type_def = match state.variable(ident) {
@@ -230,7 +231,7 @@ impl Target {
             External(path) => {
                 let td = match path {
                     None => type_def,
-                    Some(path) => type_def.for_path(path.clone()),
+                    Some(path) => type_def.for_path(&path.to_lookup()),
                 };
 
                 let type_def = match state.target() {
diff --git a/lib/vrl/compiler/src/expression/block.rs b/lib/vrl/compiler/src/expression/block.rs
index 86b77a5b51425..ce84242080014 100644
--- a/lib/vrl/compiler/src/expression/block.rs
+++ b/lib/vrl/compiler/src/expression/block.rs
@@ -42,7 +42,7 @@ impl Expression for Block {
         let fallible = type_defs.iter().any(TypeDef::is_fallible);
 
         // The last expression determines the resulting value of the block.
-        let type_def = type_defs.pop().unwrap_or_else(|| TypeDef::new().null());
+        let type_def = type_defs.pop().unwrap_or_else(TypeDef::null);
 
         type_def.with_fallibility(fallible)
     }
diff --git a/lib/vrl/compiler/src/expression/function_call.rs b/lib/vrl/compiler/src/expression/function_call.rs
index 635b1d694959b..33222a63047de 100644
--- a/lib/vrl/compiler/src/expression/function_call.rs
+++ b/lib/vrl/compiler/src/expression/function_call.rs
@@ -118,7 +118,8 @@ impl FunctionCall {
             })?;
 
             // Check if the argument is of the expected type.
-            let expr_kind = argument.type_def(state).kind();
+            let argument_type_def = argument.type_def(state);
+            let expr_kind = argument_type_def.kind();
             let param_kind = parameter.kind();
 
             if !param_kind.intersects(expr_kind) {
@@ -130,16 +131,16 @@ impl FunctionCall {
                         .map(|arg| arg.inner().to_string())
                         .collect::<Vec<_>>(),
                     parameter: *parameter,
-                    got: expr_kind,
+                    got: expr_kind.clone(),
                     argument,
                     argument_span,
                 });
-            } else if !param_kind.contains(expr_kind) {
+            } else if !param_kind.is_superset(expr_kind) {
                 maybe_fallible_arguments = true;
             }
 
             // Check if the argument is infallible.
-            if argument.type_def(state).is_fallible() {
+            if argument_type_def.is_fallible() {
                 return Err(Error::FallibleArgument {
                     expr_span: argument.span(),
                 });
@@ -364,11 +365,11 @@ impl Expression for FunctionCall {
         // For the third event, both functions fail.
         //
         if self.maybe_fallible_arguments {
-            type_def.fallible = true;
+            type_def = type_def.with_fallibility(true);
         }
 
         if self.abort_on_error {
-            type_def.fallible = false;
+            type_def = type_def.with_fallibility(false);
         }
 
         type_def
@@ -661,7 +662,7 @@ impl DiagnosticError for Error {
                 let kind_str = |kind: &Kind| {
                     if kind.is_any() {
                         kind.to_string()
-                    } else if !kind.is_many() {
+                    } else if kind.is_exact() {
                         format!(r#"the exact type {}"#, kind)
                     } else {
                         format!("one of {}", kind)
@@ -717,24 +718,37 @@ impl DiagnosticError for Error {
                 ..
             } => {
                 // TODO: move this into a generic helper function
-                let guard = match parameter.kind() {
-                    Kind::Bytes => format!("string!({})", argument),
-                    Kind::Integer => format!("int!({})", argument),
-                    Kind::Float => format!("float!({})", argument),
-                    Kind::Boolean => format!("bool!({})", argument),
-                    Kind::Object => format!("object!({})", argument),
-                    Kind::Array => format!("array!({})", argument),
-                    Kind::Timestamp => format!("timestamp!({})", argument),
-                    _ => return vec![],
+                let kind = parameter.kind();
+                let guard = if kind.is_bytes() {
+                    format!("string!({})", argument)
+                } else if kind.is_integer() {
+                    format!("int!({})", argument)
+                } else if kind.is_float() {
+                    format!("float!({})", argument)
+                } else if kind.is_boolean() {
+                    format!("bool!({})", argument)
+                } else if kind.is_object() {
+                    format!("object!({})", argument)
+                } else if kind.is_array() {
+                    format!("array!({})", argument)
+                } else if kind.is_timestamp() {
+                    format!("timestamp!({})", argument)
+                } else {
+                    return vec![];
                 };
 
-                let coerce = match parameter.kind() {
-                    Kind::Bytes => Some(format!(r#"to_string({}) ?? "default""#, argument)),
-                    Kind::Integer => Some(format!("to_int({}) ?? 0", argument)),
-                    Kind::Float => Some(format!("to_float({}) ?? 0", argument)),
-                    Kind::Boolean => Some(format!("to_bool({}) ?? false", argument)),
-                    Kind::Timestamp => Some(format!("to_timestamp({}) ?? now()", argument)),
-                    _ => None,
+                let coerce = if kind.is_bytes() {
+                    Some(format!(r#"to_string({}) ?? "default""#, argument))
+                } else if kind.is_integer() {
+                    Some(format!("to_int({}) ?? 0", argument))
+                } else if kind.is_float() {
+                    Some(format!("to_float({}) ?? 0", argument))
+                } else if kind.is_boolean() {
+                    Some(format!("to_bool({}) ?? false", argument))
+                } else if kind.is_timestamp() {
+                    Some(format!("to_timestamp({}) ?? now()", argument))
+                } else {
+                    None
                 };
 
                 let args = {
@@ -798,7 +812,7 @@ mod tests {
         }
 
         fn type_def(&self, _state: &crate::State) -> TypeDef {
-            TypeDef::new().infallible()
+            TypeDef::null().infallible()
         }
     }
 
diff --git a/lib/vrl/compiler/src/expression/if_statement.rs b/lib/vrl/compiler/src/expression/if_statement.rs
index 078dac453fc63..c72af75bfdb1d 100644
--- a/lib/vrl/compiler/src/expression/if_statement.rs
+++ b/lib/vrl/compiler/src/expression/if_statement.rs
@@ -48,7 +48,7 @@ impl Expression for IfStatement {
 
         match &self.alternative {
             None => type_def,
-            Some(alternative) => type_def.merge(alternative.type_def(state)),
+            Some(alternative) => type_def.merge_deep(alternative.type_def(state)),
         }
     }
 
diff --git a/lib/vrl/compiler/src/expression/literal.rs b/lib/vrl/compiler/src/expression/literal.rs
index 9aba3e6d77bcb..36e862781cbdb 100644
--- a/lib/vrl/compiler/src/expression/literal.rs
+++ b/lib/vrl/compiler/src/expression/literal.rs
@@ -76,13 +76,13 @@ impl Expression for Literal {
         use Literal::*;
 
         let type_def = match self {
-            String(_) => TypeDef::new().bytes(),
-            Integer(_) => TypeDef::new().integer(),
-            Float(_) => TypeDef::new().float(),
-            Boolean(_) => TypeDef::new().boolean(),
-            Regex(_) => TypeDef::new().regex(),
-            Timestamp(_) => TypeDef::new().timestamp(),
-            Null => TypeDef::new().null(),
+            String(_) => TypeDef::bytes(),
+            Integer(_) => TypeDef::integer(),
+            Float(_) => TypeDef::float(),
+            Boolean(_) => TypeDef::boolean(),
+            Regex(_) => TypeDef::regex(),
+            Timestamp(_) => TypeDef::timestamp(),
+            Null => TypeDef::null(),
         };
 
         type_def.infallible()
@@ -388,12 +388,12 @@ mod tests {
     test_type_def![
         bytes {
             expr: |_| expr!("foo"),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         integer {
             expr: |_| expr!(12),
-            want: TypeDef::new().integer(),
+            want: TypeDef::integer(),
         }
     ];
 }
diff --git a/lib/vrl/compiler/src/expression/noop.rs b/lib/vrl/compiler/src/expression/noop.rs
index f9256c8ee9b68..64e57a5000e92 100644
--- a/lib/vrl/compiler/src/expression/noop.rs
+++ b/lib/vrl/compiler/src/expression/noop.rs
@@ -15,7 +15,7 @@ impl Expression for Noop {
     }
 
     fn type_def(&self, _: &State) -> TypeDef {
-        TypeDef::new().null().infallible()
+        TypeDef::null().infallible()
     }
 
     fn compile_to_vm(&self, vm: &mut Vm) -> Result<(), String> {
diff --git a/lib/vrl/compiler/src/expression/not.rs b/lib/vrl/compiler/src/expression/not.rs
index 3f9ff018b3665..c4bc47f3979a0 100644
--- a/lib/vrl/compiler/src/expression/not.rs
+++ b/lib/vrl/compiler/src/expression/not.rs
@@ -24,7 +24,7 @@ impl Not {
 
         if !type_def.is_boolean() {
             return Err(Error {
-                variant: ErrorVariant::NonBoolean(type_def.kind()),
+                variant: ErrorVariant::NonBoolean(type_def.into()),
                 not_span,
                 expr_span,
             });
@@ -48,7 +48,9 @@ impl Expression for Not {
     }
 
     fn type_def(&self, state: &State) -> TypeDef {
-        self.inner.type_def(state).boolean()
+        let fallible = self.inner.type_def(state).is_fallible();
+
+        TypeDef::boolean().with_fallibility(fallible)
     }
 
     fn compile_to_vm(&self, vm: &mut crate::vm::Vm) -> std::result::Result<(), String> {
diff --git a/lib/vrl/compiler/src/expression/object.rs b/lib/vrl/compiler/src/expression/object.rs
index a1beb1799849c..1a140629e4aa7 100644
--- a/lib/vrl/compiler/src/expression/object.rs
+++ b/lib/vrl/compiler/src/expression/object.rs
@@ -53,7 +53,12 @@ impl Expression for Object {
         // fallible.
         let fallible = type_defs.values().any(TypeDef::is_fallible);
 
-        TypeDef::new().object(type_defs).with_fallibility(fallible)
+        let collection = type_defs
+            .into_iter()
+            .map(|(field, type_def)| (field.into(), type_def.into()))
+            .collect::<BTreeMap<_, _>>();
+
+        TypeDef::object(collection).with_fallibility(fallible)
     }
 
     fn compile_to_vm(&self, vm: &mut crate::vm::Vm) -> Result<(), String> {
diff --git a/lib/vrl/compiler/src/expression/op.rs b/lib/vrl/compiler/src/expression/op.rs
index d19fb099a6f97..a98c0ffa87097 100644
--- a/lib/vrl/compiler/src/expression/op.rs
+++ b/lib/vrl/compiler/src/expression/op.rs
@@ -5,7 +5,6 @@ use diagnostic::{DiagnosticError, Label, Note, Span, Urls};
 use crate::{
     expression::{self, Expr, Noop, Resolved},
     parser::{ast, Node},
-    value,
     vm::OpCode,
     Context, Expression, State, TypeDef, Value,
 };
@@ -122,58 +121,59 @@ impl Expression for Op {
         use ast::Opcode::*;
         use value::Kind as K;
 
-        let lhs_def = self.lhs.type_def(state);
+        let mut lhs_def = self.lhs.type_def(state);
         let rhs_def = self.rhs.type_def(state);
 
-        let lhs_kind = lhs_def.kind();
-        let rhs_kind = rhs_def.kind();
-
         match self.opcode {
             // ok/err ?? ok
-            Err if rhs_def.is_infallible() => lhs_def.merge(rhs_def).infallible(),
+            Err if rhs_def.is_infallible() => lhs_def.merge_deep(rhs_def).infallible(),
 
             // ... ?? ...
-            Err => lhs_def.merge(rhs_def),
+            Err => lhs_def.merge_deep(rhs_def),
 
             // null || ...
-            Or if lhs_kind.is_null() => rhs_def,
+            Or if lhs_def.is_null() => rhs_def,
 
             // not null || ...
-            Or if !(lhs_kind.contains(K::Null) || lhs_kind.contains(K::Boolean)) => lhs_def,
+            Or if !(lhs_def.is_superset(&K::null()) || lhs_def.is_superset(&K::boolean())) => {
+                lhs_def
+            }
 
             // ... || ...
-            Or if !lhs_kind.is_boolean() => {
+            Or if !lhs_def.is_boolean() => {
                 // We can remove Null from the lhs since we know that if the lhs is Null
                 // we will be taking the rhs and only the rhs type_def will then be relevant.
-                (lhs_def - K::Null).merge(rhs_def)
+                lhs_def.remove_null().expect("not empty");
+
+                lhs_def.merge_deep(rhs_def)
             }
 
-            Or => lhs_def.merge(rhs_def),
+            Or => lhs_def.merge_deep(rhs_def),
 
             // ... | ...
-            Merge => lhs_def.merge(rhs_def),
+            Merge => lhs_def.merge_deep(rhs_def),
 
             // null && ...
-            And if lhs_kind.is_null() => rhs_def
-                .fallible_unless(K::Null | K::Boolean)
-                .scalar(K::Boolean),
+            And if lhs_def.is_null() => rhs_def
+                .fallible_unless(K::null().or_boolean())
+                .with_kind(K::boolean()),
 
             // ... && ...
             And => lhs_def
-                .fallible_unless(K::Null | K::Boolean)
-                .merge(rhs_def.fallible_unless(K::Null | K::Boolean))
-                .scalar(K::Boolean),
+                .fallible_unless(K::null().or_boolean())
+                .merge_deep(rhs_def.fallible_unless(K::null().or_boolean()))
+                .with_kind(K::boolean()),
 
             // ... == ...
             // ... != ...
-            Eq | Ne => lhs_def.merge(rhs_def).boolean(),
+            Eq | Ne => lhs_def.merge_deep(rhs_def).with_kind(K::boolean()),
 
             // "b" >  "a"
             // "a" >= "a"
             // "a" <  "b"
             // "b" <= "b"
             Gt | Ge | Lt | Le if lhs_def.is_bytes() && rhs_def.is_bytes() => {
-                lhs_def.merge(rhs_def).boolean()
+                lhs_def.merge_deep(rhs_def).with_kind(K::boolean())
             }
 
             // ... >  ...
@@ -181,13 +181,13 @@ impl Expression for Op {
             // ... <  ...
             // ... <= ...
             Gt | Ge | Lt | Le => lhs_def
-                .fallible_unless(K::Integer | K::Float)
-                .merge(rhs_def.fallible_unless(K::Integer | K::Float))
-                .scalar(K::Boolean),
+                .fallible_unless(K::integer().or_float())
+                .merge_deep(rhs_def.fallible_unless(K::integer().or_float()))
+                .with_kind(K::boolean()),
 
             // ... / ...
             Div => {
-                let td = TypeDef::new().float();
+                let td = TypeDef::float();
 
                 // Division is infallible if the rhs is a literal normal float or integer.
                 match self.rhs.as_value() {
@@ -202,10 +202,10 @@ impl Expression for Op {
 
             // "bar" + ...
             // ... + "bar"
-            Add if lhs_kind.is_bytes() || rhs_kind.is_bytes() => lhs_def
-                .fallible_unless(K::Bytes | K::Null)
-                .merge(rhs_def.fallible_unless(K::Bytes | K::Null))
-                .scalar(K::Bytes),
+            Add if lhs_def.is_bytes() || rhs_def.is_bytes() => lhs_def
+                .fallible_unless(K::bytes().or_null())
+                .merge_deep(rhs_def.fallible_unless(K::bytes().or_null()))
+                .with_kind(K::bytes()),
 
             // ... + 1.0
             // ... - 1.0
@@ -215,42 +215,42 @@ impl Expression for Op {
             // 1.0 - ...
             // 1.0 * ...
             // 1.0 % ...
-            Add | Sub | Mul | Rem if lhs_kind.is_float() || rhs_kind.is_float() => lhs_def
-                .fallible_unless(K::Integer | K::Float)
-                .merge(rhs_def.fallible_unless(K::Integer | K::Float))
-                .scalar(K::Float),
+            Add | Sub | Mul | Rem if lhs_def.is_float() || rhs_def.is_float() => lhs_def
+                .fallible_unless(K::integer().or_float())
+                .merge_deep(rhs_def.fallible_unless(K::integer().or_float()))
+                .with_kind(K::float()),
 
             // 1 + 1
             // 1 - 1
             // 1 * 1
             // 1 % 1
-            Add | Sub | Mul | Rem if lhs_kind.is_integer() && rhs_kind.is_integer() => {
-                lhs_def.merge(rhs_def).scalar(K::Integer)
+            Add | Sub | Mul | Rem if lhs_def.is_integer() && rhs_def.is_integer() => {
+                lhs_def.merge_deep(rhs_def).with_kind(K::integer())
             }
 
             // "bar" * 1
-            Mul if lhs_kind.is_bytes() && rhs_kind.is_integer() => {
-                lhs_def.merge(rhs_def).scalar(K::Bytes)
+            Mul if lhs_def.is_bytes() && rhs_def.is_integer() => {
+                lhs_def.merge_deep(rhs_def).with_kind(K::bytes())
             }
 
             // 1 * "bar"
-            Mul if lhs_kind.is_integer() && rhs_kind.is_bytes() => {
-                lhs_def.merge(rhs_def).scalar(K::Bytes)
+            Mul if lhs_def.is_integer() && rhs_def.is_bytes() => {
+                lhs_def.merge_deep(rhs_def).with_kind(K::bytes())
             }
 
             // ... + ...
             // ... * ...
             Add | Mul => lhs_def
-                .merge(rhs_def)
+                .merge_deep(rhs_def)
                 .fallible()
-                .scalar(K::Bytes | K::Integer | K::Float),
+                .with_kind(K::bytes().or_integer().or_float()),
 
             // ... - ...
             // ... % ...
             Sub | Rem => lhs_def
-                .merge(rhs_def)
+                .merge_deep(rhs_def)
                 .fallible()
-                .scalar(K::Integer | K::Float),
+                .with_kind(K::integer().or_float()),
         }
     }
 
@@ -448,7 +448,6 @@ mod tests {
     use crate::{
         expression::{Block, IfStatement, Literal, Predicate, Variable},
         test_type_def,
-        value::Kind,
     };
     use ast::Ident;
     use ast::Opcode::*;
@@ -486,157 +485,157 @@ mod tests {
     test_type_def![
         or_exact {
             expr: |_| op(Or, "foo", true),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         or_null {
             expr: |_| op(Or, (), true),
-            want: TypeDef::new().boolean(),
+            want: TypeDef::boolean(),
         }
 
         multiply_string_integer {
             expr: |_| op(Mul, "foo", 1),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         multiply_integer_string {
             expr: |_| op(Mul, 1, "foo"),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         multiply_float_integer {
             expr: |_| op(Mul, f(1.0), 1),
-            want: TypeDef::new().float(),
+            want: TypeDef::float(),
         }
 
         multiply_integer_float {
             expr: |_| op(Mul, 1, f(1.0)),
-            want: TypeDef::new().float(),
+            want: TypeDef::float(),
         }
 
         multiply_integer_integer {
             expr: |_| op(Mul, 1, 1),
-            want: TypeDef::new().integer(),
+            want: TypeDef::integer(),
         }
 
         multiply_other {
             expr: |_| op(Mul, (), ()),
-            want: TypeDef::new().fallible().scalar(Kind::Bytes | Kind::Integer | Kind::Float),
+            want: TypeDef::bytes().fallible().add_integer().add_float(),
         }
 
         add_string_string {
             expr: |_| op(Add, "foo", "bar"),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         add_string_null {
             expr: |_| op(Add, "foo", ()),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         add_null_string {
             expr: |_| op(Add, (), "foo"),
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         add_string_bool {
             expr: |_| op(Add, "foo", true),
-            want: TypeDef::new().fallible().bytes(),
+            want: TypeDef::bytes().fallible(),
         }
 
         add_float_integer {
             expr: |_| op(Add, f(1.0), 1),
-            want: TypeDef::new().float(),
+            want: TypeDef::float(),
         }
 
         add_integer_float {
             expr: |_| op(Add, 1, f(1.0)),
-            want: TypeDef::new().float(),
+            want: TypeDef::float(),
         }
 
         add_float_other {
             expr: |_| op(Add, f(1.0), ()),
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         add_other_float {
             expr: |_| op(Add, (), f(1.0)),
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         add_integer_integer {
             expr: |_| op(Add, 1, 1),
-            want: TypeDef::new().integer(),
+            want: TypeDef::integer(),
         }
 
         add_other {
             expr: |_| op(Add, (), ()),
-            want: TypeDef::new().fallible().bytes().add_integer().add_float(),
+            want: TypeDef::bytes().add_integer().add_float().fallible(),
         }
 
         remainder_integer {
             expr: |_| op(Rem, 5, 5),
-            want: TypeDef::new().infallible().integer(),
+            want: TypeDef::integer().infallible(),
         }
 
         remainder_float {
             expr: |_| op(Rem, 5.0, 5.0),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         remainder_mixed {
             expr: |_| op(Rem, 5, 5.0),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         remainder_other {
             expr: |_| op(Rem, 5, ()),
-            want: TypeDef::new().fallible().integer().add_float(),
+            want: TypeDef::integer().add_float().fallible(),
         }
 
         subtract_integer {
             expr: |_| op(Sub, 1, 1),
-            want: TypeDef::new().infallible().integer(),
+            want: TypeDef::integer().infallible(),
         }
 
         subtract_float {
             expr: |_| op(Sub, 1.0, 1.0),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         subtract_mixed {
             expr: |_| op(Sub, 1, 1.0),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         subtract_other {
             expr: |_| op(Sub, 1, ()),
-            want: TypeDef::new().fallible().integer().add_float(),
+            want: TypeDef::integer().fallible().add_float(),
         }
 
         divide_integer_literal {
             expr: |_| op(Div, 1, 1),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         divide_float_literal {
             expr: |_| op(Div, 1.0, 1.0),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         divide_mixed_literal {
             expr: |_| op(Div, 1, 1.0),
-            want: TypeDef::new().infallible().float(),
+            want: TypeDef::float().infallible(),
         }
 
         divide_float_zero_literal {
             expr: |_| op(Div, 1, 0.0),
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         divide_integer_zero_literal {
             expr: |_| op(Div, 1, 0),
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         divide_lhs_literal_wrong_rhs {
@@ -645,7 +644,7 @@ mod tests {
                 rhs: Box::new(Literal::from(NotNan::new(1.0).unwrap()).into()),
                 opcode: Div,
             },
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         divide_dynamic_rhs {
@@ -654,142 +653,142 @@ mod tests {
                 rhs: Box::new(Variable::noop(Ident::new("foo")).into()),
                 opcode: Div,
             },
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         divide_other {
             expr: |_| op(Div, 1.0, ()),
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         and_null {
             expr: |_| op(And, (), ()),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         and_boolean {
             expr: |_| op(And, true, true),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         and_mixed {
             expr: |_| op(And, (), true),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         and_other {
             expr: |_| op(And, (), "bar"),
-            want: TypeDef::new().fallible().boolean(),
+            want: TypeDef::boolean().fallible(),
         }
 
         equal {
             expr: |_| op(Eq, (), ()),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         not_equal {
             expr: |_| op(Ne, (), "foo"),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_integer {
             expr: |_| op(Gt, 1, 1),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_float {
             expr: |_| op(Gt, 1.0, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_mixed {
             expr: |_| op(Gt, 1, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_bytes {
             expr: |_| op(Gt, "c", "b"),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_other {
             expr: |_| op(Gt, 1, "foo"),
-            want: TypeDef::new().fallible().boolean(),
+            want: TypeDef::boolean().fallible(),
         }
 
         greater_or_equal_integer {
             expr: |_| op(Ge, 1, 1),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_or_equal_float {
             expr: |_| op(Ge, 1.0, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_or_equal_mixed {
             expr: |_| op(Ge, 1, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_or_equal_bytes {
             expr: |_| op(Ge, "foo", "foo"),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         greater_or_equal_other {
             expr: |_| op(Ge, 1, "foo"),
-            want: TypeDef::new().fallible().boolean(),
+            want: TypeDef::boolean().fallible(),
         }
 
         less_integer {
             expr: |_| op(Lt, 1, 1),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_float {
             expr: |_| op(Lt, 1.0, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_mixed {
             expr: |_| op(Lt, 1, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_bytes {
             expr: |_| op(Lt, "bar", "foo"),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_other {
             expr: |_| op(Lt, 1, "foo"),
-            want: TypeDef::new().fallible().boolean(),
+            want: TypeDef::boolean().fallible(),
         }
 
         less_or_equal_integer {
             expr: |_| op(Le, 1, 1),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_or_equal_float {
             expr: |_| op(Le, 1.0, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_or_equal_mixed {
             expr: |_| op(Le, 1, 1.0),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_or_equal_bytes {
             expr: |_| op(Le, "bar", "bar"),
-            want: TypeDef::new().infallible().boolean(),
+            want: TypeDef::boolean().infallible(),
         }
 
         less_or_equal_other {
             expr: |_| op(Le, 1, "baz"),
-            want: TypeDef::new().fallible().boolean(),
+            want: TypeDef::boolean().fallible(),
         }
 
         error_or_rhs_infallible {
@@ -802,7 +801,7 @@ mod tests {
                 rhs: Box::new(Literal::from(true).into()),
                 opcode: Err,
             },
-            want: TypeDef::new().float().add_boolean(),
+            want: TypeDef::float().add_boolean(),
         }
 
         error_or_fallible {
@@ -819,7 +818,7 @@ mod tests {
                 }.into()),
                 opcode: Err,
             },
-            want: TypeDef::new().fallible().float(),
+            want: TypeDef::float().fallible(),
         }
 
         error_or_nested_infallible {
@@ -840,7 +839,7 @@ mod tests {
                 }.into()),
                 opcode: Err,
             },
-            want: TypeDef::new().float().add_bytes(),
+            want: TypeDef::float().add_bytes(),
         }
 
         or_nullable {
@@ -854,7 +853,7 @@ mod tests {
                 rhs: Box::new(Literal::from("another string").into()),
                 opcode: Or,
             },
-            want: TypeDef::new().bytes(),
+            want: TypeDef::bytes(),
         }
 
         or_not_nullable {
@@ -868,7 +867,7 @@ mod tests {
                 rhs: Box::new(Literal::from("another string").into()),
                 opcode: Or,
             },
-            want: TypeDef::new().bytes().add_integer(),
+            want: TypeDef::bytes().add_integer(),
         }
     ];
 }
diff --git a/lib/vrl/compiler/src/expression/predicate.rs b/lib/vrl/compiler/src/expression/predicate.rs
index 56ec2a0f21547..af6fe5829aa9d 100644
--- a/lib/vrl/compiler/src/expression/predicate.rs
+++ b/lib/vrl/compiler/src/expression/predicate.rs
@@ -30,7 +30,7 @@ impl Predicate {
 
         if !type_def.is_boolean() {
             return Err(Error {
-                variant: ErrorVariant::NonBoolean(type_def.kind()),
+                variant: ErrorVariant::NonBoolean(type_def.into()),
                 span,
             });
         }
@@ -66,7 +66,7 @@ impl Expression for Predicate {
         let fallible = type_defs.iter().any(TypeDef::is_fallible);
 
         // The last expression determines the resulting value of the predicate.
-        let type_def = type_defs.pop().unwrap_or_else(|| TypeDef::new().null());
+        let type_def = type_defs.pop().unwrap_or_else(TypeDef::null);
 
         type_def.with_fallibility(fallible)
     }
diff --git a/lib/vrl/compiler/src/expression/query.rs b/lib/vrl/compiler/src/expression/query.rs
index 7336caef081b2..34a7013b5167c 100644
--- a/lib/vrl/compiler/src/expression/query.rs
+++ b/lib/vrl/compiler/src/expression/query.rs
@@ -1,6 +1,7 @@
 use std::{collections::BTreeMap, fmt};
 
 use lookup::LookupBuf;
+use value::{kind::remove, Kind};
 
 use crate::{
     expression::{assignment, Container, FunctionCall, Resolved, Variable},
@@ -50,15 +51,24 @@ impl Query {
         }
     }
 
-    pub fn delete_type_def(&self, state: &mut State) {
-        if self.is_external() {
-            if let Some(ref mut target) = state.target().as_mut() {
-                let value = target.value.clone();
-                let type_def = target.type_def.remove_path(&self.path);
+    pub fn delete_type_def(&self, state: &mut State) -> Result<Option<Kind>, remove::Error> {
+        if let Some(ref mut target) = state.target().as_mut() {
+            let value = target.value.clone();
+            let mut type_def = target.type_def.clone();
 
-                state.update_target(assignment::Details { type_def, value })
-            }
+            let result = type_def.remove_at_path(
+                &self.path.to_lookup(),
+                remove::Strategy {
+                    coalesced_path: remove::CoalescedPath::Reject,
+                },
+            );
+
+            state.update_target(assignment::Details { type_def, value });
+
+            return result;
         }
+
+        Ok(None)
     }
 }
 
@@ -105,20 +115,18 @@ impl Expression for Query {
                 //
                 // TODO: make sure to enforce this
                 if self.path.is_root() {
-                    return TypeDef::new()
-                        .object::<String, TypeDef>(BTreeMap::default())
-                        .infallible();
+                    return TypeDef::object(BTreeMap::default()).infallible();
                 }
 
                 match state.target() {
-                    None => TypeDef::new().unknown().infallible(),
-                    Some(details) => details.clone().type_def.at_path(self.path.clone()),
+                    None => TypeDef::any().infallible(),
+                    Some(details) => details.clone().type_def.at_path(&self.path.to_lookup()),
                 }
             }
 
-            Internal(variable) => variable.type_def(state).at_path(self.path.clone()),
-            FunctionCall(call) => call.type_def(state).at_path(self.path.clone()),
-            Container(container) => container.type_def(state).at_path(self.path.clone()),
+            Internal(variable) => variable.type_def(state).at_path(&self.path.to_lookup()),
+            FunctionCall(call) => call.type_def(state).at_path(&self.path.to_lookup()),
+            Container(container) => container.type_def(state).at_path(&self.path.to_lookup()),
         }
     }
 
diff --git a/lib/vrl/compiler/src/expression/variable.rs b/lib/vrl/compiler/src/expression/variable.rs
index 1461552fec606..26f50938fefca 100644
--- a/lib/vrl/compiler/src/expression/variable.rs
+++ b/lib/vrl/compiler/src/expression/variable.rs
@@ -59,7 +59,7 @@ impl Expression for Variable {
             .variable(&self.ident)
             .cloned()
             .map(|d| d.type_def)
-            .unwrap_or_else(|| TypeDef::new().null().infallible())
+            .unwrap_or_else(|| TypeDef::null().infallible())
     }
 
     fn compile_to_vm(&self, vm: &mut Vm) -> Result<(), String> {
diff --git a/lib/vrl/compiler/src/function.rs b/lib/vrl/compiler/src/function.rs
index 83deae6eaf7e6..0fdd75526b211 100644
--- a/lib/vrl/compiler/src/function.rs
+++ b/lib/vrl/compiler/src/function.rs
@@ -4,13 +4,14 @@ use std::{
 };
 
 use diagnostic::{DiagnosticError, Label, Note};
+use value::kind::Collection;
 
 use crate::{
     expression::{
         container::Variant, Container, Expr, Expression, FunctionArgument, Literal, Query,
     },
     parser::Node,
-    value::Kind,
+    value::{kind, Kind},
     vm::VmArgumentList,
     Context, ExpressionError, Span, Value,
 };
@@ -127,8 +128,49 @@ pub struct Parameter {
 }
 
 impl Parameter {
+    #[allow(arithmetic_overflow)]
     pub fn kind(&self) -> Kind {
-        Kind::new(self.kind)
+        let mut kind = Kind::empty();
+
+        let n = self.kind;
+
+        if (n & kind::BYTES) == kind::BYTES {
+            kind.add_bytes();
+        }
+
+        if (n & kind::INTEGER) == kind::INTEGER {
+            kind.add_integer();
+        }
+
+        if (n & kind::FLOAT) == kind::FLOAT {
+            kind.add_float();
+        }
+
+        if (n & kind::BOOLEAN) == kind::BOOLEAN {
+            kind.add_boolean();
+        }
+
+        if (n & kind::OBJECT) == kind::OBJECT {
+            kind.add_object(Collection::any());
+        }
+
+        if (n & kind::ARRAY) == kind::ARRAY {
+            kind.add_array(Collection::any());
+        }
+
+        if (n & kind::TIMESTAMP) == kind::TIMESTAMP {
+            kind.add_timestamp();
+        }
+
+        if (n & kind::REGEX) == kind::REGEX {
+            kind.add_regex();
+        }
+
+        if (n & kind::NULL) == kind::NULL {
+            kind.add_null();
+        }
+
+        kind
     }
 }
 
@@ -443,3 +485,47 @@ impl From<Error> for Box<dyn diagnostic::DiagnosticError> {
         Box::new(error) as _
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parameter_kind() {
+        struct TestCase {
+            parameter_kind: u16,
+            kind: Kind,
+        }
+
+        for (
+            title,
+            TestCase {
+                parameter_kind,
+                kind,
+            },
+        ) in HashMap::from([
+            (
+                "bytes",
+                TestCase {
+                    parameter_kind: kind::BYTES,
+                    kind: Kind::bytes(),
+                },
+            ),
+            (
+                "integer",
+                TestCase {
+                    parameter_kind: kind::INTEGER,
+                    kind: Kind::integer(),
+                },
+            ),
+        ]) {
+            let parameter = Parameter {
+                keyword: "",
+                kind: parameter_kind,
+                required: false,
+            };
+
+            assert_eq!(parameter.kind(), kind, "{}", title);
+        }
+    }
+}
diff --git a/lib/vrl/compiler/src/lib.rs b/lib/vrl/compiler/src/lib.rs
index 62eac405f02d7..972fe55f5ead2 100644
--- a/lib/vrl/compiler/src/lib.rs
+++ b/lib/vrl/compiler/src/lib.rs
@@ -11,6 +11,7 @@ pub mod type_def;
 pub mod value;
 pub mod vm;
 
+pub use crate::value::Value;
 pub use context::Context;
 pub(crate) use diagnostic::Span;
 pub use expression::{Expression, ExpressionError, Resolved};
@@ -20,7 +21,6 @@ pub use program::Program;
 pub(crate) use state::Compiler as State;
 pub use target::Target;
 pub use type_def::TypeDef;
-pub use value::Value;
 
 pub type Result = std::result::Result<Program, compiler::Errors>;
 
diff --git a/lib/vrl/compiler/src/state.rs b/lib/vrl/compiler/src/state.rs
index 4d3ffe0eade96..208cb675d75d0 100644
--- a/lib/vrl/compiler/src/state.rs
+++ b/lib/vrl/compiler/src/state.rs
@@ -6,15 +6,19 @@ use crate::{expression::assignment, parser::ast::Ident, TypeDef, Value};
 ///
 /// This state allows the compiler to track certain invariants during
 /// compilation, which in turn drives our progressive type checking system.
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct Compiler {
-    /// stored external target type definition
+    /// Stored external target type definitions.
+    //
+    // TODO(Jean): Change this to point to a `value::Collection<Field>` type, to ensure the target
+    // is always an object. Although we probably also need to support arrays, in which case we
+    // should wrap it in an enum to also support `value::Collection<Index>`.
     target: Option<assignment::Details>,
 
-    /// stored internal variable type definitions
+    /// Stored internal variable type definitions.
     variables: HashMap<Ident, assignment::Details>,
 
-    /// context passed between the client program and a VRL function.
+    /// Context passed between the client program and a VRL function.
     external_context: Option<Box<dyn Any>>,
 
     /// On request, the compiler can store its state in this field, which can
diff --git a/lib/vrl/compiler/src/test_util.rs b/lib/vrl/compiler/src/test_util.rs
index 8133b019ef37b..9bb3db310b414 100644
--- a/lib/vrl/compiler/src/test_util.rs
+++ b/lib/vrl/compiler/src/test_util.rs
@@ -150,32 +150,34 @@ macro_rules! map {
 #[macro_export]
 macro_rules! type_def {
     (unknown) => {
-        TypeDef::new().unknown()
+        TypeDef::any()
     };
 
     (bytes) => {
-        TypeDef::new().bytes()
+        TypeDef::bytes()
     };
 
-    (object { $($key:expr => $value:expr,)+ }) => {
-        TypeDef::new().object::<&'static str, TypeDef>(btreemap! (
-            $($key => $value,)+
-        ))
-    };
+    (object {$(unknown => $unknown:expr,)? $($key:literal => $value:expr,)+ }) => {{
+        let mut v = value::kind::Collection::from(::std::collections::BTreeMap::from([$(($key.into(), $value.into()),)+]));
+        $(v.set_unknown(value::Kind::from($unknown)))?;
 
-    (array [ $($value:expr,)+ ]) => {
-        TypeDef::new().array_mapped::<(), TypeDef>(btreemap! (
-            $(() => $value,)+
-        ))
-    };
+        TypeDef::object(v)
+    }};
 
-    (array { $($idx:expr => $value:expr,)+ }) => {
-        TypeDef::new().array_mapped::<Index, TypeDef>(btreemap! (
-            $($idx => $value,)+
-        ))
-    };
+    (array [ $($value:expr,)+ ]) => {{
+        $(let v = value::kind::Collection::from_unknown(value::Kind::from($value));)+
+
+        TypeDef::array(v)
+    }};
+
+    (array { $(unknown => $unknown:expr,)? $($idx:literal => $value:expr,)+ }) => {{
+        let mut v = value::kind::Collection::from(::std::collections::BTreeMap::from([$(($idx.into(), $value.into()),)+]));
+        $(v.set_unknown(value::Kind::from($unknown)))?;
+
+        TypeDef::array(v)
+    }};
 
     (array) => {
-        TypeDef::new().array_mapped::<i32, TypeDef>(btreemap! ())
+        TypeDef::array(::std::collections::BTreeMap::default())
     };
 }
diff --git a/lib/vrl/compiler/src/type_def.rs b/lib/vrl/compiler/src/type_def.rs
index 9fb2fabe59e1a..c02bddef8fa95 100644
--- a/lib/vrl/compiler/src/type_def.rs
+++ b/lib/vrl/compiler/src/type_def.rs
@@ -22,16 +22,21 @@
 //! `Object` is a Map of `Field` -> `KindInfo`.
 //! `Field` can be a specifix field name of the object, or `Any` which represents any element found
 //! within that object.
-//!
-//!
+
 use std::{
-    collections::{BTreeMap, BTreeSet},
-    ops::Sub,
+    borrow::Cow,
+    ops::{Deref, DerefMut},
 };
 
-use lookup::{FieldBuf, LookupBuf, SegmentBuf};
-
-use crate::{map, value::Kind};
+use lookup::Lookup;
+use value::{
+    kind::{
+        merge,
+        nest::{CoalescedPath, Strategy},
+        Collection, Field, Index,
+    },
+    Kind,
+};
 
 /// Properties for a given expression that express the expected outcome of the
 /// expression.
@@ -41,559 +46,61 @@ pub struct TypeDef {
     ///
     /// Some expressions are infallible (e.g. the [`Literal`][crate::expression::Literal] expression, or any
     /// custom function designed to be infallible).
-    pub fallible: bool,
-
-    /// The [`value::Kind`][crate::value::Kind]s this definition represents.
-    ///
-    /// This is wrapped in a [`TypeKind`] enum, such that we encode details
-    /// about potential inner kinds for collections (arrays or objects).
-    pub kind: KindInfo,
-}
-
-impl Sub<Kind> for TypeDef {
-    type Output = Self;
-
-    /// Removes the given kinds from this type definition.
-    fn sub(mut self, other: Kind) -> Self::Output {
-        self.kind = match self.kind {
-            KindInfo::Unknown => KindInfo::Unknown,
-            KindInfo::Known(kinds) => {
-                KindInfo::Known(kinds.into_iter().filter(|k| k.to_kind() != other).collect())
-            }
-        };
-
-        self
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
-pub enum KindInfo {
-    Unknown,
-    Known(BTreeSet<TypeKind>),
-}
-
-impl From<Kind> for KindInfo {
-    fn from(kind: Kind) -> Self {
-        let info = Self::Unknown;
-
-        if kind.is_empty() || kind.is_all() {
-            return info;
-        }
-
-        let mut set = BTreeSet::default();
-
-        if kind.contains_bytes() {
-            set.insert(TypeKind::Bytes);
-        }
-        if kind.contains_integer() {
-            set.insert(TypeKind::Integer);
-        }
-        if kind.contains_float() {
-            set.insert(TypeKind::Float);
-        }
-        if kind.contains_boolean() {
-            set.insert(TypeKind::Boolean);
-        }
-        if kind.contains_timestamp() {
-            set.insert(TypeKind::Timestamp);
-        }
-        if kind.contains_regex() {
-            set.insert(TypeKind::Regex);
-        }
-        if kind.contains_null() {
-            set.insert(TypeKind::Null);
-        }
-        if kind.contains_array() {
-            let mut map = BTreeMap::default();
-            map.insert(Index::Any, Self::Unknown);
-            set.insert(TypeKind::Array(map));
-        }
-        if kind.contains_object() {
-            let mut map = BTreeMap::default();
-            map.insert(Field::Any, Self::Unknown);
-            set.insert(TypeKind::Object(map));
-        }
-
-        Self::Known(set)
-    }
-}
-
-impl KindInfo {
-    pub fn or_null(self) -> Self {
-        use KindInfo::*;
-
-        match self {
-            Unknown => Unknown,
-            Known(mut set) => {
-                set.insert(TypeKind::Null);
-                Known(set)
-            }
-        }
-    }
-
-    fn object(&self) -> Option<&BTreeMap<Field, KindInfo>> {
-        match self {
-            KindInfo::Unknown => None,
-            KindInfo::Known(set) => set.iter().find_map(|k| match k {
-                TypeKind::Object(object) => Some(object),
-                _ => None,
-            }),
-        }
-    }
-
-    fn array(&self) -> Option<&BTreeMap<Index, KindInfo>> {
-        match self {
-            KindInfo::Unknown => None,
-            KindInfo::Known(set) => set.iter().find_map(|k| match k {
-                TypeKind::Array(array) => Some(array),
-                _ => None,
-            }),
-        }
-    }
-
-    /// Insert the given [`KindInfo`] into a provided path.
-    ///
-    /// For example, given kind info:
-    ///
-    /// KindInfo {
-    ///   Object {
-    ///     "bar": KindInfo {
-    ///       Bytes
-    ///     }
-    ///   }
-    /// }
-    ///
-    /// And a path `.foo`, This would return:
-    ///
-    ///
-    /// KindInfo {
-    ///   Object {
-    ///     "foo": KindInfo {
-    ///       Object {
-    ///         "bar" : KindInfo {
-    ///           Bytes
-    ///         }
-    ///       }
-    ///     }
-    ///   }
-    /// }
-    ///
-    /// e.g., the existing [`KindInfo`] gets nested into the provided path.
-    pub fn for_path(mut self, path: LookupBuf) -> Self {
-        for segment in path.iter().rev() {
-            match segment {
-                SegmentBuf::Field(FieldBuf { name, .. }) => {
-                    let mut map = BTreeMap::default();
-                    map.insert(Field::Field(name.as_str().to_owned()), self);
-
-                    let mut set = BTreeSet::new();
-                    set.insert(TypeKind::Object(map));
-
-                    self = KindInfo::Known(set);
-                }
-                SegmentBuf::Coalesce(fields) => {
-                    // TODO: I'm not sure this is right - it should be the
-                    // combined typedef of all the fields in the coalesce.
-                    let field = fields.last().unwrap();
-                    let mut map = BTreeMap::default();
-                    map.insert(Field::Field(field.as_str().to_owned()), self);
-
-                    let mut set = BTreeSet::new();
-                    set.insert(TypeKind::Object(map));
-
-                    self = KindInfo::Known(set);
-                }
-                SegmentBuf::Index(index) => {
-                    // For negative indices, we have to mark the array contents
-                    // as unknown.
-                    let (index, info) = if index.is_negative() {
-                        (Index::Any, KindInfo::Unknown)
-                    } else {
-                        (Index::Index(*index as usize), self)
-                    };
-
-                    let mut map = BTreeMap::default();
-                    map.insert(index, info);
-
-                    let mut set = BTreeSet::new();
-                    set.insert(TypeKind::Array(map));
-
-                    self = KindInfo::Known(set);
-                }
-            }
-        }
-
-        self
-    }
-
-    /// Given a [`KindInfo`], try to fetch the inner [`KindInfo`] based on the
-    /// provided path.
-    ///
-    /// For example, Given kind info:
-    ///
-    /// KindInfo {
-    ///   Object {
-    ///     "foo": KindInfo {
-    ///       Bytes
-    ///     }
-    ///   }
-    /// }
-    ///
-    /// And a path `.foo`. This would return `KindInfo::Bytes`.
-    pub fn at_path(&self, path: LookupBuf) -> Self {
-        let mut iter = path.into_iter();
-
-        let info = match self {
-            kind @ KindInfo::Unknown => return kind.clone(),
-            kind @ KindInfo::Known(_) => {
-                let new = match iter.next() {
-                    None => return kind.clone(),
-                    Some(segment) => match segment {
-                        SegmentBuf::Coalesce(fields) => match kind.object() {
-                            None => KindInfo::Unknown,
-                            Some(kind) => fields
-                                .into_iter()
-                                .find_map(|field| {
-                                    let field = Field::Field(field.as_str().to_owned());
-                                    kind.get(&field).cloned()
-                                })
-                                .unwrap_or_else(|| {
-                                    if let Some(kind) = kind.get(&Field::Any) {
-                                        kind.clone()
-                                    } else {
-                                        KindInfo::Unknown
-                                    }
-                                }),
-                        },
-                        SegmentBuf::Field(FieldBuf { name: field, .. }) => match kind.object() {
-                            None => KindInfo::Unknown,
-                            Some(kind) => {
-                                let field = Field::Field(field.as_str().to_owned());
-
-                                if let Some(kind) = kind.get(&field) {
-                                    kind.clone()
-                                } else if let Some(kind) = kind.get(&Field::Any) {
-                                    kind.clone()
-                                } else {
-                                    KindInfo::Unknown
-                                }
-                            }
-                        },
-                        SegmentBuf::Index(index) => match kind.array() {
-                            None => KindInfo::Unknown,
-                            Some(kind) => {
-                                let index = Index::Index(index as usize);
-
-                                if let Some(kind) = kind.get(&index) {
-                                    kind.clone()
-                                } else if let Some(kind) = kind.get(&Index::Any) {
-                                    kind.clone()
-                                } else {
-                                    KindInfo::Unknown
-                                }
-                            }
-                        },
-                    },
-                };
-
-                match kind {
-                    KindInfo::Known(set) if set.len() > 1 => new.or_null(),
-                    _ => new,
-                }
-            }
-        };
-
-        info.at_path(LookupBuf::from_segments(iter.collect()))
-    }
-
-    fn merge(self, rhs: Self, shallow: bool, overwrite: bool) -> Self {
-        use KindInfo::*;
-
-        match (self, rhs) {
-            (KindInfo::Known(lhs), KindInfo::Known(rhs)) => {
-                let (lhs_array, lhs): (Vec<_>, Vec<_>) = lhs
-                    .into_iter()
-                    .partition(|k| matches!(k, TypeKind::Array(_)));
-                let lhs_array = lhs_array
-                    .into_iter()
-                    .filter_map(|k| match k {
-                        TypeKind::Array(v) => Some(v),
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>()
-                    .pop();
-
-                let (rhs_array, rhs): (Vec<_>, Vec<_>) = rhs
-                    .into_iter()
-                    .partition(|k| matches!(k, TypeKind::Array(_)));
-                let rhs_array = rhs_array
-                    .into_iter()
-                    .filter_map(|k| match k {
-                        TypeKind::Array(v) => Some(v),
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>()
-                    .pop();
-
-                // If both the lhs and rhs contain an array, we need to merge
-                // their definitions.
-                //
-                // We do this by taking the highest index of the lhs array, and
-                // increase the indexes of the rhs index by that amount.
-                #[allow(clippy::suspicious_arithmetic_impl)]
-                let array = lhs_array
-                    .clone()
-                    .zip(rhs_array.clone())
-                    .map(|(mut l, mut r)| {
-                        if !overwrite {
-                            let r_start = l
-                                .keys()
-                                .filter_map(|i| i.to_inner())
-                                .max()
-                                .map(|i| i + 1)
-                                .unwrap_or_default();
-
-                            r = r
-                                .into_iter()
-                                .map(|(i, v)| (i.shift(r_start), v))
-                                .collect::<BTreeMap<_, _>>();
-                        };
-
-                        l.append(&mut r);
-                        l
-                    })
-                    .or_else(|| lhs_array.or(rhs_array));
-
-                let (lhs_object, lhs): (Vec<_>, Vec<_>) = lhs
-                    .into_iter()
-                    .partition(|k| matches!(k, TypeKind::Object(_)));
-                let lhs_object = lhs_object
-                    .into_iter()
-                    .filter_map(|k| match k {
-                        TypeKind::Object(v) => Some(v),
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>()
-                    .pop();
-
-                let (rhs_object, rhs): (Vec<_>, Vec<_>) = rhs
-                    .into_iter()
-                    .partition(|k| matches!(k, TypeKind::Object(_)));
-                let rhs_object = rhs_object
-                    .into_iter()
-                    .filter_map(|k| match k {
-                        TypeKind::Object(v) => Some(v),
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>()
-                    .pop();
+    fallible: bool,
 
-                // Similar to merging two arrays, but for objects.
-                //
-                // In this case, all we care about is merging the two objects,
-                // with the rhs object taking precedence.
-                let object = lhs_object
-                    .clone()
-                    .zip(rhs_object.clone())
-                    .map(|(mut l, mut r)| {
-                        // merge nested keys, if requested
-                        if !shallow {
-                            for (k1, v1) in l.iter_mut() {
-                                for (k2, v2) in r.iter_mut() {
-                                    if k1 == k2 {
-                                        *v2 = v1.clone().merge(v2.clone(), false, false);
-                                    }
-                                }
-                            }
-                        }
-
-                        l.append(&mut r);
-                        l
-                    })
-                    .or_else(|| lhs_object.or(rhs_object));
-
-                let mut lhs: BTreeSet<_> = lhs.into_iter().collect();
-                let mut rhs = rhs.into_iter().collect();
-                lhs.append(&mut rhs);
-
-                if let Some(array) = array {
-                    lhs.insert(TypeKind::Array(array));
-                }
-
-                if let Some(object) = object {
-                    lhs.insert(TypeKind::Object(object));
-                }
-                Known(lhs)
-            }
-            (lhs @ Known(_), _) => lhs,
-            (_, rhs @ Known(_)) => rhs,
-            _ => Unknown,
-        }
-    }
-
-    fn map<F>(&self, f: F) -> Self
-    where
-        F: Fn(&TypeKind) -> TypeKind,
-    {
-        match self {
-            Self::Unknown => Self::Unknown,
-            Self::Known(set) => Self::Known(set.iter().map(f).collect()),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
-pub enum TypeKind {
-    Bytes,
-    Integer,
-    Float,
-    Boolean,
-    Timestamp,
-    Regex,
-    Null,
-    Array(BTreeMap<Index, KindInfo>),
-    Object(BTreeMap<Field, KindInfo>),
+    /// The [`Kind`][value::Kind]s this definition represents.
+    kind: Kind,
 }
 
-impl TypeKind {
-    /// Convert a given [`TypeKind`] into a [`Kind`].
-    pub fn to_kind(&self) -> Kind {
-        use TypeKind::*;
-
-        match self {
-            Bytes => Kind::Bytes,
-            Integer => Kind::Integer,
-            Float => Kind::Float,
-            Boolean => Kind::Boolean,
-            Timestamp => Kind::Timestamp,
-            Regex => Kind::Regex,
-            Null => Kind::Null,
-            Array(_) => Kind::Array,
-            Object(_) => Kind::Object,
-        }
-    }
-
-    /// Collects the kinds into a single kind.
-    /// Array and objects may have different kinds for each key/index, this collects those
-    /// into a single kind.
-    pub fn collect_kinds(self) -> TypeKind {
-        match self {
-            TypeKind::Array(kinds) => {
-                let mut newkinds = BTreeMap::new();
-                newkinds.insert(
-                    Index::Any,
-                    kinds
-                        .into_iter()
-                        .fold(KindInfo::Unknown, |acc, (_, k)| acc.merge(k, false, true)),
-                );
-                TypeKind::Array(newkinds)
-            }
-
-            TypeKind::Object(kinds) => {
-                let mut newkinds = BTreeMap::new();
-                newkinds.insert(
-                    Field::Any,
-                    kinds
-                        .into_iter()
-                        .fold(KindInfo::Unknown, |acc, (_, k)| acc.merge(k, false, true)),
-                );
-                TypeKind::Object(newkinds)
-            }
-            _ => self,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
-pub enum Index {
-    Any,
-    Index(usize),
-}
-
-impl Index {
-    fn to_inner(self) -> Option<usize> {
-        match self {
-            Index::Any => None,
-            Index::Index(i) => Some(i),
-        }
-    }
-
-    fn shift(self, count: usize) -> Self {
-        match self {
-            Index::Index(i) => Index::Index(i + count),
-            v => v,
-        }
-    }
-}
-
-impl From<usize> for Index {
-    fn from(i: usize) -> Self {
-        Self::Index(i)
-    }
-}
-
-impl From<i32> for Index {
-    fn from(i: i32) -> Self {
-        Self::Index(i as usize)
-    }
-}
-
-impl From<()> for Index {
-    fn from(_: ()) -> Self {
-        Self::Any
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
-pub enum Field {
-    Any,
-    Field(String),
-}
-
-impl From<String> for Field {
-    fn from(k: String) -> Self {
-        Self::Field(k)
-    }
-}
+impl Deref for TypeDef {
+    type Target = Kind;
 
-impl From<&'static str> for Field {
-    fn from(k: &'static str) -> Self {
-        Self::Field(k.to_owned())
+    fn deref(&self) -> &Self::Target {
+        &self.kind
     }
 }
 
-impl From<()> for Field {
-    fn from(_: ()) -> Self {
-        Self::Any
+impl DerefMut for TypeDef {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.kind
     }
 }
 
 impl TypeDef {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn kind(&self) -> &Kind {
+        &self.kind
     }
 
-    pub fn at_path(&self, path: LookupBuf) -> TypeDef {
+    pub fn at_path(&self, path: &Lookup<'_>) -> TypeDef {
         let fallible = self.fallible;
-        let kind = self.kind.at_path(path);
+
+        let kind = self
+            .kind
+            .find_at_path(path)
+            .ok()
+            .flatten()
+            .map(Cow::into_owned)
+            .unwrap_or_else(Kind::any);
 
         Self { fallible, kind }
     }
 
-    pub fn for_path(self, path: LookupBuf) -> TypeDef {
+    pub fn for_path(self, path: &Lookup<'_>) -> TypeDef {
         let fallible = self.fallible;
-        let kind = self.kind.for_path(path);
+        let kind = self
+            .kind
+            .clone()
+            .nest_at_path(
+                path,
+                Strategy {
+                    coalesced_path: CoalescedPath::Reject,
+                },
+            )
+            .unwrap_or(self.kind);
 
         Self { fallible, kind }
     }
 
-    pub fn kind(&self) -> Kind {
-        match &self.kind {
-            KindInfo::Unknown => Kind::all(),
-            KindInfo::Known(set) => set.iter().fold(Kind::empty(), |acc, k| acc | k.to_kind()),
-        }
-    }
-
     #[inline]
     pub fn fallible(mut self) -> Self {
         self.fallible = true;
@@ -613,333 +120,173 @@ impl TypeDef {
     }
 
     #[inline]
-    pub fn unknown(mut self) -> Self {
-        self.kind = KindInfo::Unknown;
-        self
+    pub fn any() -> Self {
+        Kind::any().into()
     }
 
     #[inline]
-    pub fn bytes(self) -> Self {
-        self.scalar(Kind::Bytes)
+    pub fn bytes() -> Self {
+        Kind::bytes().into()
     }
 
     #[inline]
-    pub fn add_bytes(self) -> Self {
-        self.add_scalar(Kind::Bytes)
-    }
-
-    #[inline]
-    pub fn integer(self) -> Self {
-        self.scalar(Kind::Integer)
-    }
-
-    #[inline]
-    pub fn add_integer(self) -> Self {
-        self.add_scalar(Kind::Integer)
+    pub fn add_bytes(mut self) -> Self {
+        self.kind.add_bytes();
+        self
     }
 
     #[inline]
-    pub fn float(self) -> Self {
-        self.scalar(Kind::Float)
+    pub fn integer() -> Self {
+        Kind::integer().into()
     }
 
     #[inline]
-    pub fn add_float(self) -> Self {
-        self.add_scalar(Kind::Float)
+    pub fn add_integer(mut self) -> Self {
+        self.kind.add_integer();
+        self
     }
 
     #[inline]
-    pub fn boolean(self) -> Self {
-        self.scalar(Kind::Boolean)
+    pub fn float() -> Self {
+        Kind::float().into()
     }
 
     #[inline]
-    pub fn add_boolean(self) -> Self {
-        self.add_scalar(Kind::Boolean)
+    pub fn add_float(mut self) -> Self {
+        self.kind.add_float();
+        self
     }
 
     #[inline]
-    pub fn timestamp(self) -> Self {
-        self.scalar(Kind::Timestamp)
+    pub fn boolean() -> Self {
+        Kind::boolean().into()
     }
 
     #[inline]
-    pub fn add_timestamp(self) -> Self {
-        self.add_scalar(Kind::Timestamp)
+    pub fn add_boolean(mut self) -> Self {
+        self.kind.add_boolean();
+        self
     }
 
     #[inline]
-    pub fn regex(self) -> Self {
-        self.scalar(Kind::Regex)
+    pub fn timestamp() -> Self {
+        Kind::timestamp().into()
     }
 
     #[inline]
-    pub fn add_regex(self) -> Self {
-        self.add_scalar(Kind::Regex)
+    pub fn add_timestamp(mut self) -> Self {
+        self.kind.add_timestamp();
+        self
     }
 
     #[inline]
-    pub fn null(self) -> Self {
-        self.scalar(Kind::Null)
+    pub fn regex() -> Self {
+        Kind::regex().into()
     }
 
     #[inline]
-    pub fn add_null(self) -> Self {
-        self.add_scalar(Kind::Null)
-    }
-
-    /// Set the type definition kind to a scalar.
-    ///
-    /// This overwrites any existing kind information.
-    #[inline]
-    pub fn scalar(self, kind: Kind) -> Self {
-        self.unknown().add_scalar(kind)
-    }
-
-    /// Add a new scalar kind to the type definition.
-    ///
-    /// This appends the new scalars to the existing kinds.
-    pub fn add_scalar(mut self, kind: Kind) -> Self {
-        debug_assert!(kind.is_scalar());
-
-        self.kind = self.kind.merge(kind.into(), false, false);
+    pub fn add_regex(mut self) -> Self {
+        self.kind.add_regex();
         self
     }
 
     #[inline]
-    pub fn array<V>(self, inner: Vec<V>) -> Self
-    where
-        V: Into<Self>,
-    {
-        self.unknown().add_array(inner)
+    pub fn null() -> Self {
+        Kind::null().into()
     }
 
     #[inline]
-    pub fn add_array<V>(self, inner: Vec<V>) -> Self
-    where
-        V: Into<Self>,
-    {
-        let map = inner.into_iter().enumerate().fold(
-            BTreeMap::<Index, _>::default(),
-            |mut acc, (i, td)| {
-                acc.insert(i.into(), td.into());
-                acc
-            },
-        );
-
-        self.add_array_mapped(map)
+    pub fn add_null(mut self) -> Self {
+        self.kind.add_null();
+        self
     }
 
     #[inline]
-    pub fn restrict_array(mut self) -> Self {
-        match self.kind {
-            KindInfo::Known(set) => {
-                self.kind = KindInfo::Known(
-                    set.into_iter()
-                        .filter(|k| matches!(k, TypeKind::Array(_)))
-                        .collect(),
-                );
-                self
-            }
-            KindInfo::Unknown => self.array_mapped::<(), Kind>(map! { (): Kind::all() }),
-        }
+    pub fn array(collection: impl Into<Collection<Index>>) -> Self {
+        Kind::array(collection).into()
     }
 
     #[inline]
-    pub fn array_mapped<I, V>(self, map: BTreeMap<I, V>) -> Self
-    where
-        I: Into<Index>,
-        V: Into<Self>,
-    {
-        self.unknown().add_array_mapped(map)
+    pub fn add_array(mut self, collection: impl Into<Collection<Index>>) -> Self {
+        self.kind.add_array(collection);
+        self
     }
 
+    /// Convert the [`TypeDef`]s [`Kind`] to an array.
+    ///
+    /// If `Kind` already has the array state, all other states are removed. If it does not yet
+    /// have an array, then equally all existing states are removed, and an "any" array state is
+    /// added.
+    ///
+    /// `TypeDef`s fallibility is kept unmodified.
     #[inline]
-    pub fn add_array_mapped<I, V>(mut self, map: BTreeMap<I, V>) -> Self
-    where
-        I: Into<Index>,
-        V: Into<Self>,
-    {
-        // must not have multiple arrays in list
-        self = self.remove_array();
-
-        let map = map
-            .into_iter()
-            .map(|(i, td)| (i.into(), td.into().kind))
-            .collect::<BTreeMap<_, _>>();
-
-        self.add_container(TypeKind::Array(map))
-    }
+    pub fn restrict_array(self) -> Self {
+        let fallible = self.fallible;
+        let collection = match self.kind.into_array() {
+            Some(array) => array,
+            None => Collection::any(),
+        };
 
-    #[inline]
-    pub fn object<K, V>(self, inner: BTreeMap<K, V>) -> Self
-    where
-        K: Into<Field>,
-        V: Into<Self>,
-    {
-        self.unknown().add_object(inner)
+        Self {
+            fallible,
+            kind: Kind::array(collection),
+        }
     }
 
     #[inline]
-    pub fn add_object<K, V>(mut self, inner: BTreeMap<K, V>) -> Self
-    where
-        K: Into<Field>,
-        V: Into<Self>,
-    {
-        // must not have multiple objects in list
-        self = self.remove_object();
-
-        let map = inner
-            .into_iter()
-            .fold(BTreeMap::default(), |mut acc, (k, td)| {
-                acc.insert(k.into(), td.into().kind);
-                acc
-            });
-
-        self.add_container(TypeKind::Object(map))
+    pub fn object(collection: impl Into<Collection<Field>>) -> Self {
+        Kind::object(collection).into()
     }
 
     #[inline]
-    pub fn restrict_object(mut self) -> Self {
-        match self.kind {
-            KindInfo::Known(set) => {
-                self.kind = KindInfo::Known(
-                    set.into_iter()
-                        .filter(|k| matches!(k, TypeKind::Object(_)))
-                        .collect(),
-                );
-                self
-            }
-            KindInfo::Unknown => self.object::<(), Kind>(map! { (): Kind::all() }),
-        }
-    }
-
-    fn add_container(mut self, kind: TypeKind) -> Self {
-        debug_assert!(matches!(kind, TypeKind::Array(_) | TypeKind::Object(_)));
-
-        let mut set = BTreeSet::default();
-        set.insert(kind);
-
-        self.kind = self.kind.merge(KindInfo::Known(set), false, false);
+    pub fn add_object(mut self, collection: impl Into<Collection<Field>>) -> Self {
+        self.kind.add_object(collection);
         self
     }
 
-    fn remove_array(mut self) -> Self {
-        self.kind = match self.kind {
-            KindInfo::Known(set) => KindInfo::Known(
-                set.into_iter()
-                    .filter(|k| !matches!(k, TypeKind::Array(_)))
-                    .collect(),
-            ),
-            v => v,
+    /// Convert the [`TypeDef`]s [`Kind`] to an object.
+    ///
+    /// If `Kind` already has the object state, all other states are removed. If it does not yet
+    /// have an object, then equally all existing states are removed, and an "any" object state is
+    /// added.
+    ///
+    /// `TypeDef`s fallibility is kept unmodified.
+    #[inline]
+    pub fn restrict_object(self) -> Self {
+        let fallible = self.fallible;
+        let collection = match self.kind.into_object() {
+            Some(object) => object,
+            None => Collection::any(),
         };
 
-        self
+        Self {
+            fallible,
+            kind: Kind::object(collection),
+        }
     }
 
-    fn remove_object(mut self) -> Self {
-        self.kind = match self.kind {
-            KindInfo::Known(set) => KindInfo::Known(
-                set.into_iter()
-                    .filter(|k| !matches!(k, TypeKind::Object(_)))
-                    .collect(),
-            ),
-            v => v,
-        };
-
+    #[inline]
+    pub fn with_kind(mut self, kind: Kind) -> Self {
+        self.kind = kind;
         self
     }
 
-    /// Collects any subtypes that can contain multiple indexed types (array, object) and collects them into
-    /// a single type for all indexes.
-    /// Used for functions that cant determine which indexes of a collection have been used in the result.
+    /// Collects any subtypes that can contain multiple indexed types (array, object) and collects
+    /// them into a single type for all indexes.
+    ///
+    /// Used for functions that cant determine which indexes of a collection have been used in the
+    /// result.
     pub fn collect_subtypes(mut self) -> Self {
-        self.kind = match self.kind {
-            KindInfo::Known(set) => {
-                KindInfo::Known(set.into_iter().map(|k| k.collect_kinds()).collect())
-            }
-            v => v,
-        };
-
-        self
-    }
-
-    #[inline]
-    pub fn is_unknown(&self) -> bool {
-        matches!(self.kind, KindInfo::Unknown)
-    }
-
-    #[inline]
-    pub fn is_bytes(&self) -> bool {
-        self.is("bytes")
-    }
-
-    #[inline]
-    pub fn is_integer(&self) -> bool {
-        self.is("integer")
-    }
-
-    #[inline]
-    pub fn is_float(&self) -> bool {
-        self.is("float")
-    }
-
-    #[inline]
-    pub fn is_boolean(&self) -> bool {
-        self.is("boolean")
-    }
-
-    #[inline]
-    pub fn is_timestamp(&self) -> bool {
-        self.is("timestamp")
-    }
-
-    #[inline]
-    pub fn is_regex(&self) -> bool {
-        self.is("regex")
-    }
-
-    #[inline]
-    pub fn is_null(&self) -> bool {
-        self.is("null")
-    }
-
-    #[inline]
-    pub fn is_array(&self) -> bool {
-        self.is("array")
-    }
-
-    #[inline]
-    pub fn is_object(&self) -> bool {
-        self.is("object")
-    }
-
-    fn is(&self, kind: &'static str) -> bool {
-        match &self.kind {
-            KindInfo::Unknown => false,
-            KindInfo::Known(set) if set.len() == 1 => {
-                let v = set.iter().next().unwrap();
-                match kind {
-                    "bytes" => matches!(v, TypeKind::Bytes),
-                    "integer" => matches!(v, TypeKind::Integer),
-                    "float" => matches!(v, TypeKind::Float),
-                    "boolean" => matches!(v, TypeKind::Boolean),
-                    "timestamp" => matches!(v, TypeKind::Timestamp),
-                    "regex" => matches!(v, TypeKind::Regex),
-                    "null" => matches!(v, TypeKind::Null),
-                    "array" => matches!(v, TypeKind::Array(_)),
-                    "object" => matches!(v, TypeKind::Object(_)),
-                    _ => unreachable!("implementation error"),
-                }
-            }
-            KindInfo::Known(_) => false,
+        if let Some(object) = self.kind.as_object_mut() {
+            object.set_unknown(None);
+            object.anonymize();
+        }
+        if let Some(array) = self.kind.as_array_mut() {
+            array.set_unknown(None);
+            array.anonymize();
         }
-    }
-
-    // -------------------------------------------------------------------------
 
-    pub fn has_kind(&self, kind: impl Into<Kind>) -> bool {
-        self.kind().intersects(kind.into())
+        self
     }
 
     // -------------------------------------------------------------------------
@@ -956,384 +303,79 @@ impl TypeDef {
     /// within the provided kind.
     pub fn fallible_unless(mut self, kind: impl Into<Kind>) -> Self {
         let kind = kind.into();
-        if !kind.contains(self.kind()) {
+        if !kind.is_superset(&self.kind) {
             self.fallible = true
         }
 
         self
     }
 
-    fn update_segment<'a, I>(
-        kind: &KindInfo,
-        mut path: std::iter::Peekable<I>,
-        newkind: &KindInfo,
-    ) -> KindInfo
-    where
-        I: std::iter::Iterator<Item = &'a SegmentBuf> + Clone,
-    {
-        let next_segment = |path: &mut std::iter::Peekable<I>, kindinfo| {
-            // Keep recursing until we reach the end of the path at which point we take the new
-            // kind.
-            if path.peek().is_some() {
-                Self::update_segment(kindinfo, path.clone(), newkind)
-            } else {
-                newkind.clone()
-            }
-        };
-
-        match kind {
-            KindInfo::Unknown => {
-                // The kind is unknown and thus there is nothing to remove.
-                kind.clone()
-            }
-            KindInfo::Known(kinds) => KindInfo::Known(
-                kinds
-                    .iter()
-                    .map(|kind| match (kind, path.next()) {
-                        (TypeKind::Object(object), Some(SegmentBuf::Field(fieldname))) => {
-                            // Is there an exact fieldname specified for the given path field?
-                            let indexed = object.iter().any(|(field, _)| {
-                                matches!(field,
-                                    Field::Field(field) if field == fieldname.as_str())
-                            });
-
-                            TypeKind::Object(
-                                object
-                                    .iter()
-                                    .flat_map(|(field, kindinfo)| match field {
-                                        Field::Field(f) if f == fieldname.as_str() => {
-                                            vec![(field.clone(), next_segment(&mut path, kindinfo))]
-                                                .into_iter()
-                                        }
-
-                                        Field::Any if !indexed => {
-                                            // If this specific field wasn't defined for the
-                                            // object, we want to retain the original Any
-                                            // definition and insert our new specific field
-                                            // definition.
-                                            vec![
-                                                (field.clone(), kindinfo.clone()),
-                                                (
-                                                    Field::Field(fieldname.as_str().to_string()),
-                                                    next_segment(&mut path, kindinfo),
-                                                ),
-                                            ]
-                                            .into_iter()
-                                        }
-
-                                        _ => vec![(field.clone(), kindinfo.clone())].into_iter(),
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (TypeKind::Object(object), Some(SegmentBuf::Coalesce(fieldnames))) => {
-                            TypeKind::Object(
-                                object
-                                    .iter()
-                                    .map(|(field, kindinfo)| {
-                                        let kind = next_segment(&mut path, kindinfo);
-
-                                        match field {
-                                            Field::Field(ref name)
-                                                if fieldnames.iter().any(|fieldname| {
-                                                    name == fieldname.as_str()
-                                                }) =>
-                                            {
-                                                // Coalesced fields can also be Null if the coalesced value
-                                                // goes down the other branch.
-                                                (field.clone(), kind.or_null())
-                                            }
-                                            _ => (field.clone(), kind),
-                                        }
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (TypeKind::Array(array), Some(SegmentBuf::Index(index))) => {
-                            // Is an exact index type definition specified for the given path
-                            // segment?
-                            let indexed = array.iter().any(|(idx, _kindinfo)| {
-                                matches!(idx,
-                                    Index::Index(idx) if *index > 0 && *idx == *index as usize)
-                            });
-
-                            TypeKind::Array(
-                                array
-                                    .iter()
-                                    .flat_map(|(idx, kindinfo)| match idx {
-                                        Index::Index(idx)
-                                            if *index >= 0 && *idx == *index as usize =>
-                                        {
-                                            vec![(
-                                                Index::Index(*idx),
-                                                next_segment(&mut path, kindinfo),
-                                            )]
-                                            .into_iter()
-                                        }
-                                        _ if *index < 0 => {
-                                            // If we have specified a negative index we need to merge this
-                                            // type since we aren't sure the precise index this is
-                                            // specifying since it's dependant on the array length
-                                            // at runtime.
-                                            vec![(
-                                                *idx,
-                                                kindinfo.clone().merge(
-                                                    next_segment(&mut path, kindinfo),
-                                                    false,
-                                                    true,
-                                                ),
-                                            )]
-                                            .into_iter()
-                                        }
-                                        Index::Any if !indexed => {
-                                            // If there is an Any type specified, and we know that
-                                            // there isn't a type specified for the index provided
-                                            // in the type, we need to add a specific typedef just
-                                            // for the index.
-                                            vec![
-                                                (
-                                                    Index::Index(*index as usize),
-                                                    next_segment(&mut path, kindinfo),
-                                                ),
-                                                (*idx, kindinfo.clone()),
-                                            ]
-                                            .into_iter()
-                                        }
-                                        _ => vec![(*idx, kindinfo.clone())].into_iter(),
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (kind, _) => kind.clone(),
-                    })
-                    .collect(),
-            ),
-        }
-    }
-
-    /// Updates the type definition at the given path with the provided kind.
-    pub fn update_path(&self, path: &LookupBuf, kind: &KindInfo) -> Self {
-        let segments = path.as_segments();
-        let peekable = segments.iter().peekable();
-        let kind = Self::update_segment(&self.kind, peekable, kind);
-
-        TypeDef {
-            fallible: self.fallible,
-            kind,
-        }
-    }
-
-    /// Performs a bitwise-or operation, and returns the resulting type definition.
-    pub fn merge(self, rhs: Self) -> Self {
-        Self {
-            fallible: self.fallible | rhs.fallible,
-            kind: self.kind.merge(rhs.kind, false, false),
-        }
-    }
-
-    /// Performs a shallow bitwise-or operation, and returns the resulting type
-    /// definition.
-    pub fn merge_shallow(self, rhs: Self) -> Self {
-        Self {
-            fallible: self.fallible | rhs.fallible,
-            kind: self.kind.merge(rhs.kind, true, false),
-        }
-    }
-
-    /// Merge two type definitions, where the rhs type definition should
-    /// overwrite any conflicting values in the lhs type definition.
-    pub fn merge_overwrite(self, rhs: Self) -> Self {
-        Self {
-            fallible: self.fallible | rhs.fallible,
-            kind: self.kind.merge(rhs.kind, false, true),
-        }
+    pub fn merge_deep(mut self, other: Self) -> Self {
+        self.merge(
+            other,
+            merge::Strategy {
+                depth: merge::Depth::Deep,
+                indices: merge::Indices::Keep,
+            },
+        );
+        self
     }
 
-    /// For any array defined by this type def, allows you to map the indexed kind
-    /// to a new kind.
-    pub fn map_array<F>(&self, f: F) -> Self
-    where
-        F: Fn(&KindInfo) -> KindInfo,
-    {
-        let newkind = self.kind.map(|k| match k {
-            TypeKind::Array(array) => TypeKind::Array(
-                array
-                    .iter()
-                    .map(|(index, kind)| (*index, f(kind)))
-                    .collect(),
-            ),
-            k => k.clone(),
-        });
-
-        Self {
-            fallible: self.fallible,
-            kind: newkind,
-        }
+    pub fn merge_shallow(mut self, other: Self) -> Self {
+        self.merge(
+            other,
+            merge::Strategy {
+                depth: merge::Depth::Shallow,
+                indices: merge::Indices::Keep,
+            },
+        );
+        self
     }
 
-    fn remove_segment<'a, I>(kind: &KindInfo, mut path: std::iter::Peekable<I>) -> KindInfo
-    where
-        I: std::iter::Iterator<Item = &'a SegmentBuf> + Clone,
-    {
-        match kind {
-            KindInfo::Unknown => {
-                // The kind is unknown and thus there is nothing to remove.
-                kind.clone()
-            }
-            KindInfo::Known(kinds) => KindInfo::Known(
-                kinds
-                    .iter()
-                    .map(|kind| match (kind, path.next(), path.peek()) {
-                        (TypeKind::Object(object), Some(SegmentBuf::Field(fieldname)), Some(_)) => {
-                            TypeKind::Object(
-                                object
-                                    .iter()
-                                    .map(|(field, kindinfo)| match field {
-                                        Field::Field(name) if name == fieldname.as_str() => (
-                                            field.clone(),
-                                            Self::remove_segment(kindinfo, path.clone()),
-                                        ),
-                                        _ => (field.clone(), kindinfo.clone()),
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (TypeKind::Object(object), Some(SegmentBuf::Field(fieldname)), None) => {
-                            TypeKind::Object(
-                                object
-                                    .iter()
-                                    .filter_map(|(field, kindinfo)| match field {
-                                        Field::Field(name) if name == fieldname.as_str() => None,
-                                        _ => Some((field.clone(), kindinfo.clone())),
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (
-                            TypeKind::Object(object),
-                            Some(SegmentBuf::Coalesce(fieldnames)),
-                            Some(_),
-                        ) => TypeKind::Object(
-                            object
-                                .iter()
-                                .map(|(field, kindinfo)| match field {
-                                    Field::Field(name)
-                                        if fieldnames
-                                            .iter()
-                                            .any(|fieldname| fieldname.as_str() == name) =>
-                                    {
-                                        (
-                                            field.clone(),
-                                            Self::remove_segment(kindinfo, path.clone()),
-                                        )
-                                    }
-                                    _ => (field.clone(), kindinfo.clone()),
-                                })
-                                .collect(),
-                        ),
-
-                        (
-                            TypeKind::Object(object),
-                            Some(SegmentBuf::Coalesce(fieldnames)),
-                            None,
-                        ) => TypeKind::Object(
-                            object
-                                .iter()
-                                .filter_map(|(field, kindinfo)| match field {
-                                    Field::Field(name)
-                                        if fieldnames
-                                            .iter()
-                                            .any(|fieldname| fieldname.as_str() == name) =>
-                                    {
-                                        // With coalesced paths we need to remove all fields within
-                                        // the coalesce.
-                                        None
-                                    }
-                                    _ => Some((field.clone(), kindinfo.clone())),
-                                })
-                                .collect(),
-                        ),
-
-                        (TypeKind::Array(array), Some(SegmentBuf::Index(index)), Some(_)) => {
-                            TypeKind::Array(
-                                array
-                                    .iter()
-                                    .map(|(idx, kindinfo)| match idx {
-                                        Index::Index(idx)
-                                            if *index >= 0 && *idx == *index as usize =>
-                                        {
-                                            (
-                                                Index::Index(*idx),
-                                                Self::remove_segment(kindinfo, path.clone()),
-                                            )
-                                        }
-                                        _ => (*idx, kindinfo.clone()),
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (TypeKind::Array(array), Some(SegmentBuf::Index(index)), None) => {
-                            TypeKind::Array(
-                                array
-                                    .iter()
-                                    .filter_map(|(idx, kindinfo)| match idx {
-                                        Index::Index(idx)
-                                            if *index >= 0 && *idx == *index as usize =>
-                                        {
-                                            None
-                                        }
-                                        Index::Index(idx)
-                                            if *index >= 0 && *idx > *index as usize =>
-                                        {
-                                            // Elements after the removed index need the index
-                                            // shifting down one.
-                                            Some((Index::Index(idx - 1), kindinfo.clone()))
-                                        }
-                                        Index::Index(_) if *index < 0 => {
-                                            // After attempting to delete an element in an array
-                                            // with a negative index we can no longer maintain the
-                                            // type definition of any specific element in the array
-                                            // as we don't know which precise index is deleted
-                                            // until runtime.
-                                            None
-                                        }
-                                        _ => Some((*idx, kindinfo.clone())),
-                                    })
-                                    .collect(),
-                            )
-                        }
-
-                        (kind, _, _) => kind.clone(),
-                    })
-                    .collect(),
-            ),
-        }
+    /// Merge two type definitions.
+    ///
+    /// When merging arrays, the elements of `other` are *appended* to the elements of `self`.
+    /// Meaning, the indices of `other` are updated, to continue onward from the last index of
+    /// `self`.
+    pub fn merge_append(mut self, other: Self) -> Self {
+        self.merge(
+            other,
+            merge::Strategy {
+                depth: merge::Depth::Shallow,
+                indices: merge::Indices::Append,
+            },
+        );
+        self
     }
 
-    /// Removes the given path from the typedef
-    pub fn remove_path(&self, path: &LookupBuf) -> Self {
-        let segments = path.as_segments();
-        let peekable = segments.iter().peekable();
+    pub fn merge(&mut self, other: Self, strategy: merge::Strategy) {
+        self.fallible |= other.fallible;
 
-        TypeDef {
-            fallible: self.fallible,
-            kind: Self::remove_segment(&self.kind, peekable),
+        // NOTE: technically we shouldn't do this, but to keep backward compatibility with the
+        // "old" `Kind` implementation, we consider a type that is marked as "any" equal to the old
+        // implementation's `unknown`, which, when merging, would discard that type.
+        //
+        // see: https://github.com/vectordotdev/vector/blob/18415050b60b08197e8135b7659390256995e844/lib/vrl/compiler/src/type_def.rs#L428-L429
+        if !self.is_any() && other.is_any() {
+            // keep `self`'s `kind` definition
+        } else if self.is_any() && !other.is_any() {
+            // overwrite `self`'s `kind` definition with `others`'s
+            self.kind = other.kind;
+        } else {
+            // merge the two `kind`s
+            self.kind.merge(other.kind, strategy);
         }
     }
-}
 
-impl Default for TypeDef {
-    fn default() -> Self {
-        Self {
-            fallible: false,
-            kind: KindInfo::Unknown,
-        }
+    pub fn merge_overwrite(mut self, other: Self) -> Self {
+        self.merge(
+            other,
+            merge::Strategy {
+                depth: merge::Depth::Shallow,
+                indices: merge::Indices::Keep,
+            },
+        );
+        self
     }
 }
 
@@ -1341,436 +383,13 @@ impl From<Kind> for TypeDef {
     fn from(kind: Kind) -> Self {
         Self {
             fallible: false,
-            kind: kind.into(),
+            kind,
         }
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use lookup::{FieldBuf, SegmentBuf};
-    use vector_common::btreemap;
-
-    use super::*;
-    use crate::type_def;
-
-    #[test]
-    fn collect_subtypes() {
-        let kind = TypeKind::Array({
-            let mut set1 = BTreeSet::new();
-            set1.insert(TypeKind::Integer);
-            let mut set2 = BTreeSet::new();
-            set2.insert(TypeKind::Bytes);
-
-            let mut map = BTreeMap::new();
-            map.insert(Index::Index(1), KindInfo::Known(set1));
-            map.insert(Index::Index(2), KindInfo::Known(set2));
-            map
-        });
-
-        let kind = kind.collect_kinds();
-
-        let expected = TypeKind::Array({
-            let mut set = BTreeSet::new();
-            set.insert(TypeKind::Integer);
-            set.insert(TypeKind::Bytes);
-
-            let mut map = BTreeMap::new();
-            map.insert(Index::Any, KindInfo::Known(set));
-            map
-        });
-
-        assert_eq!(kind, expected);
-    }
-
-    #[test]
-    fn update_path() {
-        struct TestCase {
-            old: TypeDef,
-            path: &'static str,
-            new: TypeDef,
-        }
-
-        let cases = vec![
-            // Simple case
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array [
-                        type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    ] },
-                } },
-                path: ".nonk",
-                new: type_def! { object {
-                    "nonk" => type_def! { bytes },
-                } },
-            },
-            // Same field in different branches
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "shnoog" => type_def! { array [
-                            type_def! { object {
-                                "noog" => type_def! { bytes },
-                            } },
-                        ] },
-                    } },
-                    "nink" => type_def! { object {
-                        "shnoog" => type_def! { array [
-                            type_def! { object {
-                                "noog" => type_def! { bytes },
-                            } },
-                        ] },
-                    } },
-                } },
-                path: "nonk.shnoog",
-                new: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "shnoog" => type_def! { bytes },
-                    } },
-                    "nink" => type_def! { object {
-                        "shnoog" => type_def! { array [
-                            type_def! { object {
-                                "noog" => type_def! { bytes },
-                            } },
-                        ] },
-                    } },
-                } },
-            },
-            // Indexed any should add the new type as a specific index and retain the any.
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array [
-                        type_def! { object {
-                            "noog" => type_def! { array [
-                                type_def! { bytes },
-                            ] },
-                            "nork" => type_def! { bytes },
-                        } },
-                    ] },
-                } },
-                path: ".nonk[0].noog",
-                new: type_def! { object {
-                    "nonk" => type_def! { array {
-                        Index::Any => type_def! { object {
-                            "noog" => type_def! { array [
-                                type_def! { bytes },
-                            ] },
-                            "nork" => type_def! { bytes },
-                        } },
-                        Index::Index(0) => type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-            },
-            // Indexed specific
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array {
-                        Index::Index(0) => type_def! { object {
-                            "noog" => type_def! { array [
-                                type_def! { bytes },
-                            ] },
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-                path: ".nonk[0].noog",
-                new: type_def! { object {
-                    "nonk" => type_def! { array {
-                        Index::Index(0) => type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-            },
-            // More nested
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "shnoog" => type_def! { array [
-                            type_def! { object {
-                                "noog" => type_def! { bytes },
-                                "nork" => type_def! { bytes },
-                            } },
-                        ] },
-                    } },
-                } },
-                path: ".nonk.shnoog",
-                new: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "shnoog" => type_def! { bytes },
-                    } },
-                } },
-            },
-            // Coalesce
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "shnoog" => type_def! { array [
-                            type_def! { object {
-                                "noog" => type_def! { bytes },
-                                "nork" => type_def! { bytes },
-                            } },
-                        ] },
-                    } },
-                } },
-                path: ".(nonk | nork).shnoog",
-                new: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "shnoog" => type_def! { bytes },
-                    } }.add_null(),
-                } },
-            },
-        ];
-
-        let newkind = KindInfo::Known(std::iter::once(TypeKind::Bytes).collect());
-        for case in cases {
-            let path = LookupBuf::from_str(case.path).unwrap();
-            let new = case.old.update_path(&path, &newkind);
-            assert_eq!(case.new, new, "{}", path);
-        }
-    }
-
-    #[test]
-    fn remove_path() {
-        struct TestCase {
-            old: TypeDef,
-            path: &'static str,
-            new: TypeDef,
-        }
-
-        let cases = vec![
-            // A field is removed.
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array {
-                        0 => type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-                path: "nonk[0].noog",
-                new: type_def! { object {
-                    "nonk" => type_def! { array {
-                        0 => type_def! { object {
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-            },
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "nork" => type_def! { bytes },
-                        "nark" => type_def! { bytes },
-                    } },
-                    "noog" => type_def! { object {
-                        "nork" => type_def! { bytes },
-                        "nark" => type_def! { bytes },
-                    } },
-                } },
-                path: "nonk.nork",
-                new: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "nark" => type_def! { bytes },
-                    } },
-                    "noog" => type_def! { object {
-                        "nork" => type_def! { bytes },
-                        "nark" => type_def! { bytes },
-                    } },
-                } },
-            },
-            // Coalesced field
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "nork" => type_def! { bytes },
-                        "noog" => type_def! { bytes },
-                        "nonk" => type_def! { bytes },
-                    } },
-                } },
-                path: "nonk.(noog | nonk)",
-                new: type_def! { object {
-                    "nonk" => type_def! { object {
-                        "nork" => type_def! { bytes },
-                    } },
-                } },
-            },
-            // A single array element when the typedef is for any index.
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array [
-                        type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    ] },
-                } },
-                path: "nonk[0]",
-                new: type_def! { object {
-                    "nonk" => type_def! { array [
-                        type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    ] },
-                } },
-            },
-            // A single array element when the typedef is for that index.
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array {
-                        0 => type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-                path: "nonk[0]",
-                new: type_def! { object {
-                    "nonk" => type_def! { array },
-                } },
-            },
-            // A single array element with a negative index has to remove all typedefs.
-            TestCase {
-                old: type_def! { object {
-                    "nonk" => type_def! { array {
-                        0 => type_def! { object {
-                            "noog" => type_def! { bytes },
-                            "nork" => type_def! { bytes },
-                        } },
-                    } },
-                } },
-                path: "nonk[-1]",
-                new: type_def! { object {
-                    "nonk" => type_def! { array },
-                } },
-            },
-        ];
-
-        for case in cases {
-            let path = LookupBuf::from_str(case.path).unwrap();
-            assert_eq!(case.new, case.old.remove_path(&path));
-        }
-    }
-
-    mod kind_info {
-        use super::*;
-
-        #[test]
-        fn for_path() {
-            struct TestCase {
-                info: KindInfo,
-                path: Vec<SegmentBuf>,
-                want: KindInfo,
-            }
-
-            let cases: Vec<TestCase> = vec![
-                // overwrite unknown
-                TestCase {
-                    info: KindInfo::Unknown,
-                    path: vec![SegmentBuf::Index(0)],
-                    want: KindInfo::Known({
-                        let mut map = BTreeMap::new();
-                        map.insert(Index::Index(0), KindInfo::Unknown);
-
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Array(map));
-                        set
-                    }),
-                },
-                // insert scalar at root
-                TestCase {
-                    info: KindInfo::Known({
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Integer);
-                        set
-                    }),
-                    path: vec![],
-                    want: KindInfo::Known({
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Integer);
-                        set
-                    }),
-                },
-                // insert scalar at nested path
-                TestCase {
-                    info: KindInfo::Known({
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Integer);
-                        set
-                    }),
-                    path: vec![SegmentBuf::Field(FieldBuf::from("foo"))],
-                    want: KindInfo::Known({
-                        let map = {
-                            let mut set = BTreeSet::new();
-                            set.insert(TypeKind::Integer);
-
-                            let mut map = BTreeMap::new();
-                            map.insert(Field::Field("foo".to_owned()), KindInfo::Known(set));
-                            map
-                        };
-
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Object(map));
-                        set
-                    }),
-                },
-                // insert non-negative index
-                TestCase {
-                    info: KindInfo::Known({
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Integer);
-                        set
-                    }),
-                    path: vec![SegmentBuf::Index(1)],
-                    want: KindInfo::Known({
-                        let map = {
-                            let mut set = BTreeSet::new();
-                            set.insert(TypeKind::Integer);
-
-                            let mut map = BTreeMap::new();
-                            map.insert(Index::Index(1), KindInfo::Known(set));
-                            map
-                        };
-
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Array(map));
-                        set
-                    }),
-                },
-                // insert negative index
-                TestCase {
-                    info: KindInfo::Known({
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Integer);
-                        set
-                    }),
-                    path: vec![SegmentBuf::Index(-1)],
-                    want: KindInfo::Known({
-                        let mut set = BTreeSet::new();
-                        set.insert(TypeKind::Array({
-                            let mut map = BTreeMap::new();
-                            map.insert(Index::Any, KindInfo::Unknown);
-                            map
-                        }));
-                        set
-                    }),
-                },
-            ];
-
-            for TestCase { info, path, want } in cases {
-                let path = LookupBuf::from_segments(path);
-
-                assert_eq!(info.for_path(path), want);
-            }
-        }
+impl From<TypeDef> for Kind {
+    fn from(type_def: TypeDef) -> Self {
+        type_def.kind
     }
 }
diff --git a/lib/vrl/compiler/src/value.rs b/lib/vrl/compiler/src/value.rs
index 2ab38018008b1..a19d1642d662f 100644
--- a/lib/vrl/compiler/src/value.rs
+++ b/lib/vrl/compiler/src/value.rs
@@ -13,7 +13,7 @@ use std::{collections::BTreeMap, fmt};
 use bytes::Bytes;
 use chrono::{DateTime, SecondsFormat, Utc};
 pub use error::Error;
-pub use kind::Kind;
+pub use kind::{Collection, Field, Index, Kind};
 use ordered_float::NotNan;
 
 pub use self::regex::Regex;
diff --git a/lib/vrl/compiler/src/value/convert.rs b/lib/vrl/compiler/src/value/convert.rs
index 355dae390a491..b9ca0913913cb 100644
--- a/lib/vrl/compiler/src/value/convert.rs
+++ b/lib/vrl/compiler/src/value/convert.rs
@@ -3,6 +3,7 @@ use std::{borrow::Cow, collections::BTreeMap, convert::TryFrom, iter::FromIterat
 use bytes::Bytes;
 use chrono::{DateTime, Utc};
 use ordered_float::NotNan;
+use value::kind::Collection;
 
 use super::{Error, Kind, Regex, Value};
 use crate::{
@@ -70,7 +71,7 @@ impl Value {
             Value::Integer(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Integer,
+                expected: Kind::integer(),
             }),
         }
     }
@@ -131,7 +132,7 @@ impl TryFrom<&Value> for i64 {
         match v {
             Value::Integer(v) => Ok(*v),
             Value::Float(v) => Ok(v.into_inner() as i64),
-            _ => Err(Error::Coerce(v.kind(), Kind::Integer)),
+            _ => Err(Error::Coerce(v.kind(), Kind::integer())),
         }
     }
 }
@@ -155,7 +156,7 @@ impl Value {
             Value::Float(v) => Ok(v.into_inner()),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Float,
+                expected: Kind::float(),
             }),
         }
     }
@@ -174,7 +175,7 @@ impl TryFrom<&Value> for f64 {
         match v {
             Value::Integer(v) => Ok(*v as f64),
             Value::Float(v) => Ok(v.into_inner()),
-            _ => Err(Error::Coerce(v.kind(), Kind::Float)),
+            _ => Err(Error::Coerce(v.kind(), Kind::float())),
         }
     }
 }
@@ -217,7 +218,7 @@ impl Value {
             Value::Bytes(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Bytes,
+                expected: Kind::bytes(),
             }),
         }
     }
@@ -227,7 +228,7 @@ impl Value {
             Some(bytes) => Ok(String::from_utf8_lossy(bytes)),
             None => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Bytes,
+                expected: Kind::bytes(),
             }),
         }
     }
@@ -309,7 +310,7 @@ impl Value {
             Value::Boolean(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Boolean,
+                expected: Kind::boolean(),
             }),
         }
     }
@@ -340,7 +341,7 @@ impl Value {
             Value::Regex(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Regex,
+                expected: Kind::regex(),
             }),
         }
     }
@@ -377,7 +378,7 @@ impl Value {
             Value::Null => Ok(()),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Null,
+                expected: Kind::null(),
             }),
         }
     }
@@ -424,7 +425,7 @@ impl Value {
             Value::Array(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Array,
+                expected: Kind::array(Collection::any()),
             }),
         }
     }
@@ -468,7 +469,7 @@ impl Value {
             Value::Object(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Object,
+                expected: Kind::object(Collection::any()),
             }),
         }
     }
@@ -505,7 +506,7 @@ impl Value {
             Value::Timestamp(v) => Ok(v),
             _ => Err(Error::Expected {
                 got: self.kind(),
-                expected: Kind::Timestamp,
+                expected: Kind::timestamp(),
             }),
         }
     }
diff --git a/lib/vrl/compiler/src/value/kind.rs b/lib/vrl/compiler/src/value/kind.rs
index d3cd4099e6372..c7f65ed84fc33 100644
--- a/lib/vrl/compiler/src/value/kind.rs
+++ b/lib/vrl/compiler/src/value/kind.rs
@@ -1,6 +1,4 @@
-#![allow(non_upper_case_globals)]
-
-use std::{fmt, ops::Deref};
+use std::collections::BTreeMap;
 
 use chrono::{TimeZone, Utc};
 use regex::Regex;
@@ -22,19 +20,10 @@ pub const ANY: u16 = BYTES | INTEGER | FLOAT | BOOLEAN | OBJECT | ARRAY | TIMEST
 pub const SCALAR: u16 = BYTES | INTEGER | FLOAT | BOOLEAN | TIMESTAMP | REGEX | NULL;
 pub const CONTAINER: u16 = OBJECT | ARRAY;
 
-bitflags::bitflags! {
-    pub struct Kind: u16 {
-        const Bytes = BYTES;
-        const Integer = INTEGER;
-        const Float = FLOAT;
-        const Boolean = BOOLEAN;
-        const Object = OBJECT;
-        const Array = ARRAY;
-        const Timestamp = TIMESTAMP;
-        const Regex = REGEX;
-        const Null = NULL;
-    }
-}
+pub use ::value::{
+    kind::{find, insert, merge, nest, remove, Collection, Field, Index},
+    Kind,
+};
 
 impl Value {
     pub fn kind(&self) -> Kind {
@@ -42,90 +31,7 @@ impl Value {
     }
 }
 
-impl Kind {
-    pub const fn new(kind: u16) -> Self {
-        Kind::from_bits_truncate(kind)
-    }
-
-    /// Returns `true` if self is more than one, but not all
-    /// [`value::Kind`]s.
-    pub fn is_many(self) -> bool {
-        !self.is_exact() && !self.is_all() && !self.is_empty()
-    }
-
-    /// Returns `true` if self is any valid [`value::Kind`].
-    pub fn is_any(self) -> bool {
-        self.is_all()
-    }
-
-    /// Return the existing kinds, without non-scalar kinds (objects and arrays).
-    pub fn scalar(self) -> Self {
-        self & !(Kind::Array | Kind::Object)
-    }
-
-    /// Returns `true` if the [`value::Kind`] is a scalar and `false` if it's
-    /// map or array.
-    pub fn is_scalar(self) -> bool {
-        self == self.scalar()
-    }
-
-    /// Returns a quoted variant of `as_str`
-    ///
-    /// This function is a close duplicate of `as_str`, returning the same
-    /// underlying str but with quotes. We avoid the obvious `format!("{}",
-    /// self.as_str())` here as that incurs an allocation cost and the `Display`
-    /// of `Kind` is sometimes in the hot path.
-    ///
-    /// See https://github.com/timberio/vector/pull/6878 for details.
-    pub(crate) fn quoted(self) -> &'static str {
-        match self {
-            Kind::Bytes => "\"string\"",
-            Kind::Integer => "\"integer\"",
-            Kind::Float => "\"float\"",
-            Kind::Boolean => "\"boolean\"",
-            Kind::Object => "\"object\"",
-            Kind::Array => "\"array\"",
-            Kind::Timestamp => "\"timestamp\"",
-            Kind::Regex => "\"regex\"",
-            Kind::Null => "\"null\"",
-            _ if self.is_all() => "\"unknown type\"",
-            _ if self.is_empty() => "\"none\"",
-            _ => "\"multiple\"",
-        }
-    }
-
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Kind::Bytes => "string",
-            Kind::Integer => "integer",
-            Kind::Float => "float",
-            Kind::Boolean => "boolean",
-            Kind::Object => "object",
-            Kind::Array => "array",
-            Kind::Timestamp => "timestamp",
-            Kind::Regex => "regex",
-            Kind::Null => "null",
-            _ if self.is_all() => "unknown type",
-            _ if self.is_empty() => "none",
-            _ => "multiple",
-        }
-    }
-
-    pub fn is_exact(self) -> bool {
-        matches!(
-            self,
-            Kind::Bytes
-                | Kind::Integer
-                | Kind::Float
-                | Kind::Boolean
-                | Kind::Object
-                | Kind::Array
-                | Kind::Timestamp
-                | Kind::Regex
-                | Kind::Null
-        )
-    }
-
+pub trait DefaultValue {
     /// Returns the default [`Value`] for a given [`Kind`].
     ///
     /// If the kind is unknown (or inexact), `null` is returned as the default
@@ -135,154 +41,176 @@ impl Kind {
     /// are particularly useful for the "infallible assignment" expression,
     /// where the `ok` value is set to the default value kind if the expression
     /// results in an error.
-    pub fn default_value(self) -> Value {
-        match self {
-            Kind::Bytes => value!(""),
-            Kind::Integer => value!(0),
-            Kind::Float => value!(0.0),
-            Kind::Boolean => value!(false),
-            Kind::Object => value!({}),
-            Kind::Array => value!([]),
-            Kind::Timestamp => Utc.timestamp(0, 0).into(),
-            #[allow(clippy::trivial_regex)]
-            Kind::Regex => Regex::new("").unwrap().into(),
-            _ => Value::Null,
-        }
-    }
+    fn default_value(&self) -> Value;
 }
 
-macro_rules! impl_kind {
-    ($(($kind:tt, $name:tt)),+ $(,)*) => {
-        impl fmt::Display for Kind {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                if !self.is_many() {
-                    return write!(f, "{}", self.quoted())
-                }
-
-                let mut kinds = Vec::with_capacity(16);
-                $(paste::paste! {
-                if self.[<contains_ $name>]() {
-                    kinds.push(Kind::$kind.quoted())
-                }
-                })+
-
-                let last = kinds.pop();
-                let mut string = kinds.join(", ");
-
-                if let Some(last) = last {
-                    if !string.is_empty() {
-                        string.push_str(" or ")
-                    }
-
-                    string.push_str(&last);
-                }
-
-                f.write_str(&string)
-            }
+impl DefaultValue for Kind {
+    fn default_value(&self) -> Value {
+        if self.is_bytes() {
+            return value!("");
         }
 
-        impl Kind {
-            $(paste::paste! {
-            pub fn [<is_ $name>](self) -> bool {
-                matches!(self, Kind::$kind)
-            }
+        if self.is_integer() {
+            return value!(0);
+        }
 
-            pub fn [<contains_ $name>](self) -> bool {
-                self.contains(Kind::$kind)
-            }
-            })+
+        if self.is_float() {
+            return value!(0.0);
         }
 
-        impl IntoIterator for Kind {
-            type Item = Self;
-            type IntoIter = std::vec::IntoIter<Self::Item>;
+        if self.is_boolean() {
+            return value!(false);
+        }
 
-            fn into_iter(self) -> Self::IntoIter {
-                let mut kinds = vec![];
-                $(paste::paste! {
-                if self.[<contains_ $name>]() {
-                    kinds.push(Kind::$kind)
-                }
-                })+
+        if self.is_timestamp() {
+            return Utc.timestamp(0, 0).into();
+        }
 
-                kinds.into_iter()
-            }
+        if self.is_regex() {
+            #[allow(clippy::trivial_regex)]
+            return Regex::new("").unwrap().into();
         }
-    };
-}
 
-impl_kind![
-    (Bytes, bytes),
-    (Integer, integer),
-    (Float, float),
-    (Boolean, boolean),
-    (Object, object),
-    (Array, array),
-    (Timestamp, timestamp),
-    (Regex, regex),
-    (Null, null),
-];
+        if self.is_array() {
+            return value!([]);
+        }
 
-impl Deref for Kind {
-    type Target = str;
+        if self.is_object() {
+            return value!({});
+        }
 
-    fn deref(&self) -> &Self::Target {
-        self.as_str()
+        Value::Null
     }
 }
 
 impl From<&Value> for Kind {
     fn from(value: &Value) -> Self {
         match value {
-            Value::Bytes(_) => Kind::Bytes,
-            Value::Integer(_) => Kind::Integer,
-            Value::Float(_) => Kind::Float,
-            Value::Boolean(_) => Kind::Boolean,
-            Value::Object(_) => Kind::Object,
-            Value::Array(_) => Kind::Array,
-            Value::Timestamp(_) => Kind::Timestamp,
-            Value::Regex(_) => Kind::Regex,
-            Value::Null => Kind::Null,
+            Value::Bytes(_) => Kind::bytes(),
+            Value::Integer(_) => Kind::integer(),
+            Value::Float(_) => Kind::float(),
+            Value::Boolean(_) => Kind::boolean(),
+            Value::Timestamp(_) => Kind::timestamp(),
+            Value::Regex(_) => Kind::regex(),
+            Value::Null => Kind::null(),
+
+            Value::Object(object) => Kind::object(
+                object
+                    .iter()
+                    .map(|(k, v)| (k.clone().into(), v.into()))
+                    .collect::<BTreeMap<_, _>>(),
+            ),
+
+            Value::Array(array) => Kind::array(
+                array
+                    .iter()
+                    .enumerate()
+                    .map(|(i, v)| (i.into(), v.into()))
+                    .collect::<BTreeMap<_, _>>(),
+            ),
         }
     }
 }
 
+impl From<Value> for Kind {
+    fn from(value: Value) -> Self {
+        (&value).into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::collections::HashMap;
 
-    #[test]
-    fn quoted() {
-        for i in 0..u16::MAX {
-            let kind = Kind::new(i);
-            assert_eq!(kind.quoted(), format!(r#""{}""#, kind.as_str()));
-        }
-    }
+    use super::*;
 
     #[test]
-    fn kind_is_scalar() {
-        let scalars = vec![
-            Kind::Integer,
-            Kind::Bytes,
-            Kind::Null | Kind::Regex,
-            Kind::Timestamp | Kind::Float | Kind::Null,
-        ];
-
-        let non_scalars = vec![
-            Kind::Array,
-            Kind::Object,
-            Kind::Array | Kind::Integer,
-            Kind::Object | Kind::Array,
-            Kind::Object | Kind::Bytes,
-            Kind::Boolean | Kind::Null | Kind::Array,
-        ];
-
-        for kind in scalars {
-            assert!(kind.is_scalar());
+    fn test_from_value() {
+        struct TestCase {
+            value: Value,
+            want: Kind,
         }
 
-        for kind in non_scalars {
-            assert!(!kind.is_scalar());
+        for (title, TestCase { value, want }) in HashMap::from([
+            (
+                "bytes",
+                TestCase {
+                    value: value!("foo"),
+                    want: Kind::bytes(),
+                },
+            ),
+            (
+                "integer",
+                TestCase {
+                    value: value!(3),
+                    want: Kind::integer(),
+                },
+            ),
+            (
+                "float",
+                TestCase {
+                    value: value!(3.3),
+                    want: Kind::float(),
+                },
+            ),
+            (
+                "boolean",
+                TestCase {
+                    value: value!(true),
+                    want: Kind::boolean(),
+                },
+            ),
+            (
+                "timestamp",
+                TestCase {
+                    value: Utc::now().into(),
+                    want: Kind::timestamp(),
+                },
+            ),
+            (
+                "regex",
+                TestCase {
+                    value: Regex::new("").unwrap().into(),
+                    want: Kind::regex(),
+                },
+            ),
+            (
+                "null",
+                TestCase {
+                    value: value!(null),
+                    want: Kind::null(),
+                },
+            ),
+            (
+                "object",
+                TestCase {
+                    value: value!({ "foo": { "bar": 12 }, "baz": true }),
+                    want: Kind::object(BTreeMap::from([
+                        (
+                            "foo".into(),
+                            Kind::object(BTreeMap::from([("bar".into(), Kind::integer())])),
+                        ),
+                        ("baz".into(), Kind::boolean()),
+                    ])),
+                },
+            ),
+            (
+                "array",
+                TestCase {
+                    value: value!([12, true, "foo", { "bar": null }]),
+                    want: Kind::array(BTreeMap::from([
+                        (0.into(), Kind::integer()),
+                        (1.into(), Kind::boolean()),
+                        (2.into(), Kind::bytes()),
+                        (
+                            3.into(),
+                            Kind::object(BTreeMap::from([("bar".into(), Kind::null())])),
+                        ),
+                    ])),
+                },
+            ),
+        ]) {
+            assert_eq!(Kind::from(value), want, "{}", title);
         }
     }
 }
diff --git a/lib/vrl/compiler/src/vm/argument_list.rs b/lib/vrl/compiler/src/vm/argument_list.rs
index 8ff2534ea1ffc..c6f6ac9b1f76b 100644
--- a/lib/vrl/compiler/src/vm/argument_list.rs
+++ b/lib/vrl/compiler/src/vm/argument_list.rs
@@ -98,7 +98,7 @@ impl<'a> VmArgumentList<'a> {
         for (param, args) in self.args.iter().zip(self.values.iter()) {
             match args.as_ref() {
                 None if param.required => return Err("parameter is required".into()),
-                Some(arg) if matches!(arg.kind(), Some(kind) if !param.kind().intersects(kind)) => {
+                Some(arg) if matches!(arg.kind(), Some(kind) if !param.kind().intersects(&kind)) => {
                     return Err("parameter type mismatch".into())
                 }
                 _ => (),
diff --git a/lib/vrl/core/src/lib.rs b/lib/vrl/core/src/lib.rs
index 42f9f89dc8b20..0efb1fe76c558 100644
--- a/lib/vrl/core/src/lib.rs
+++ b/lib/vrl/core/src/lib.rs
@@ -4,8 +4,7 @@ mod runtime;
 use std::any::Any;
 
 pub use compiler::{
-    function, state, type_def::Index, value, vm::Vm, Context, Expression, Function, Program,
-    Target, Value,
+    function, state, value, vm::Vm, Context, Expression, Function, Program, Target, Value,
 };
 pub use diagnostic;
 pub use runtime::{Runtime, RuntimeResult, Terminate};
diff --git a/lib/vrl/core/src/prelude.rs b/lib/vrl/core/src/prelude.rs
index acb34d54b07ff..eb76cfff380bc 100644
--- a/lib/vrl/core/src/prelude.rs
+++ b/lib/vrl/core/src/prelude.rs
@@ -4,11 +4,13 @@ pub use compiler::{expression, state, value::kind};
 
 // commonly used top-level crate types
 pub use compiler::{
-    value::Kind, Context, Expression, ExpressionError, Function, Resolved, Target, TypeDef, Value,
+    value::{Collection, Field, Index, Kind},
+    Context, Expression, ExpressionError, Function, Resolved, Target, TypeDef, Value,
 };
 
 pub type Result<T> = std::result::Result<T, ExpressionError>;
 
+pub use std::collections::BTreeMap;
 pub use std::fmt;
 
 pub use bytes::Bytes;
diff --git a/lib/vrl/stdlib/src/append.rs b/lib/vrl/stdlib/src/append.rs
index e94fc2a9596aa..1dd55ed06e6a0 100644
--- a/lib/vrl/stdlib/src/append.rs
+++ b/lib/vrl/stdlib/src/append.rs
@@ -61,13 +61,16 @@ impl Expression for AppendFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value.type_def(state).merge(self.items.type_def(state))
+        self.value
+            .type_def(state)
+            .merge_append(self.items.type_def(state))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use vector_common::btreemap;
 
     test_function![
         append => Append;
@@ -75,42 +78,42 @@ mod tests {
         both_arrays_empty {
             args: func_args![value: value!([]), items: value!([])],
             want: Ok(value!([])),
-            tdef: TypeDef::new().array::<TypeDef>(vec![]),
+            tdef: TypeDef::array(Collection::empty()),
         }
 
         one_array_empty {
             args: func_args![value: value!([]), items: value!([1, 2, 3])],
             want: Ok(value!([1, 2, 3])),
-            tdef: TypeDef::new().array_mapped::<i32, TypeDef>(map! {
-                0: Kind::Integer,
-                1: Kind::Integer,
-                2: Kind::Integer,
+            tdef: TypeDef::array(btreemap! {
+                Index::from(0) => Kind::integer(),
+                Index::from(1) => Kind::integer(),
+                Index::from(2) => Kind::integer(),
             }),
         }
 
         neither_array_empty {
             args: func_args![value: value!([1, 2, 3]), items: value!([4, 5, 6])],
             want: Ok(value!([1, 2, 3, 4, 5, 6])),
-            tdef: TypeDef::new().array_mapped::<i32, TypeDef>(map! {
-                0: Kind::Integer,
-                1: Kind::Integer,
-                2: Kind::Integer,
-                3: Kind::Integer,
-                4: Kind::Integer,
-                5: Kind::Integer,
+            tdef: TypeDef::array(btreemap! {
+                Index::from(0) => Kind::integer(),
+                Index::from(1) => Kind::integer(),
+                Index::from(2) => Kind::integer(),
+                Index::from(3) => Kind::integer(),
+                Index::from(4) => Kind::integer(),
+                Index::from(5) => Kind::integer(),
             }),
         }
 
         mixed_array_types {
             args: func_args![value: value!([1, 2, 3]), items: value!([true, 5.0, "bar"])],
             want: Ok(value!([1, 2, 3, true, 5.0, "bar"])),
-            tdef: TypeDef::new().array_mapped::<i32, TypeDef>(map! {
-                0: Kind::Integer,
-                1: Kind::Integer,
-                2: Kind::Integer,
-                3: Kind::Boolean,
-                4: Kind::Float,
-                5: Kind::Bytes,
+            tdef: TypeDef::array(btreemap! {
+                Index::from(0) => Kind::integer(),
+                Index::from(1) => Kind::integer(),
+                Index::from(2) => Kind::integer(),
+                Index::from(3) => Kind::boolean(),
+                Index::from(4) => Kind::float(),
+                Index::from(5) => Kind::bytes(),
             }),
         }
     ];
diff --git a/lib/vrl/stdlib/src/array.rs b/lib/vrl/stdlib/src/array.rs
index 4c8fe62b0563a..508f7c33900e5 100644
--- a/lib/vrl/stdlib/src/array.rs
+++ b/lib/vrl/stdlib/src/array.rs
@@ -3,7 +3,7 @@ use vrl::prelude::*;
 fn array(value: Value) -> std::result::Result<Value, ExpressionError> {
     match value {
         v @ Value::Array(_) => Ok(v),
-        v => Err(format!(r#"expected "array", got {}"#, v.kind()).into()),
+        v => Err(format!("expected array, got {}", v.kind()).into()),
     }
 }
 
@@ -34,7 +34,7 @@ impl Function for Array {
                 title: "invalid",
                 source: "array!(true)",
                 result: Err(
-                    r#"function call error for "array" at (0:12): expected "array", got "boolean""#,
+                    r#"function call error for "array" at (0:12): expected array, got boolean"#,
                 ),
             },
         ]
@@ -74,7 +74,7 @@ impl Expression for ArrayFn {
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
         self.value
             .type_def(state)
-            .fallible_unless(Kind::Array)
+            .fallible_unless(Kind::array(Collection::any()))
             .restrict_array()
     }
 }
diff --git a/lib/vrl/stdlib/src/assert.rs b/lib/vrl/stdlib/src/assert.rs
index 3481c564492c5..3f06ed03c9584 100644
--- a/lib/vrl/stdlib/src/assert.rs
+++ b/lib/vrl/stdlib/src/assert.rs
@@ -93,8 +93,8 @@ impl Expression for AssertFn {
         }
     }
 
-    fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.condition.type_def(state).fallible().boolean()
+    fn type_def(&self, _: &state::Compiler) -> TypeDef {
+        TypeDef::boolean().fallible()
     }
 }
 
diff --git a/lib/vrl/stdlib/src/assert_eq.rs b/lib/vrl/stdlib/src/assert_eq.rs
index bc056a0a7dd93..b7ce894cc6538 100644
--- a/lib/vrl/stdlib/src/assert_eq.rs
+++ b/lib/vrl/stdlib/src/assert_eq.rs
@@ -108,7 +108,7 @@ impl Expression for AssertEqFn {
     }
 
     fn type_def(&self, _state: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().boolean()
+        TypeDef::boolean().fallible()
     }
 }
 
@@ -122,19 +122,19 @@ mod tests {
         pass {
             args: func_args![left: "foo", right: "foo"],
             want: Ok(true),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         fail {
             args: func_args![left: "foo", right: "bar"],
             want: Err(r#"assertion failed: "foo" == "bar""#),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         message {
             args: func_args![left: "foo", right: "bar", message: "failure!"],
             want: Err("failure!"),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/boolean.rs b/lib/vrl/stdlib/src/boolean.rs
index 2e882812da31f..ccee2a991d710 100644
--- a/lib/vrl/stdlib/src/boolean.rs
+++ b/lib/vrl/stdlib/src/boolean.rs
@@ -3,7 +3,7 @@ use vrl::prelude::*;
 fn boolean(value: Value) -> std::result::Result<Value, ExpressionError> {
     match value {
         v @ Value::Boolean(_) => Ok(v),
-        v => Err(format!(r#"expected "boolean", got {}"#, v.kind()).into()),
+        v => Err(format!("expected boolean, got {}", v.kind()).into()),
     }
 }
 
@@ -34,7 +34,7 @@ impl Function for Boolean {
                 title: "invalid",
                 source: "bool!(42)",
                 result: Err(
-                    r#"function call error for "bool" at (0:9): expected "boolean", got "integer""#,
+                    r#"function call error for "bool" at (0:9): expected boolean, got integer"#,
                 ),
             },
         ]
@@ -72,9 +72,8 @@ impl Expression for BooleanFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value
-            .type_def(state)
-            .fallible_unless(Kind::Boolean)
-            .boolean()
+        let non_boolean = !self.value.type_def(state).is_boolean();
+
+        TypeDef::boolean().with_fallibility(non_boolean)
     }
 }
diff --git a/lib/vrl/stdlib/src/ceil.rs b/lib/vrl/stdlib/src/ceil.rs
index bf189ea0028df..b0fc9ac5f64dd 100644
--- a/lib/vrl/stdlib/src/ceil.rs
+++ b/lib/vrl/stdlib/src/ceil.rs
@@ -64,17 +64,17 @@ impl Expression for CeilFn {
             value @ Value::Integer(_) => Ok(value),
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Float | Kind::Integer,
+                expected: Kind::float() | Kind::integer(),
             }
             .into()),
         }
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        TypeDef::new().scalar(match self.value.type_def(state).kind() {
-            v if v.is_float() || v.is_integer() => v,
-            _ => Kind::Integer | Kind::Float,
-        })
+        match Kind::from(self.value.type_def(state)) {
+            v if v.is_float() || v.is_integer() => v.into(),
+            _ => Kind::integer().or_float().into(),
+        }
     }
 }
 
@@ -88,19 +88,19 @@ mod tests {
         lower {
             args: func_args![value: value!(1234.2)],
             want: Ok(value!(1235.0)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         higher {
             args: func_args![value: value!(1234.8)],
             want: Ok(value!(1235.0)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         integer {
             args: func_args![value: value!(1234)],
             want: Ok(value!(1234)),
-            tdef: TypeDef::new().integer(),
+            tdef: TypeDef::integer(),
         }
 
         precision {
@@ -108,7 +108,7 @@ mod tests {
                              precision: value!(1)
             ],
             want: Ok(value!(1234.4)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         bigger_precision {
@@ -116,7 +116,7 @@ mod tests {
                              precision: value!(4)
             ],
             want: Ok(value!(1234.5673)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         huge_number {
@@ -124,7 +124,7 @@ mod tests {
                              precision: value!(5)
             ],
             want: Ok(value!(9876543210123456789098765432101234567890987654321.98766)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/compact.rs b/lib/vrl/stdlib/src/compact.rs
index 844cfbf1f6b70..8e2ed148898d1 100644
--- a/lib/vrl/stdlib/src/compact.rs
+++ b/lib/vrl/stdlib/src/compact.rs
@@ -183,19 +183,17 @@ impl Expression for CompactFn {
             Value::Array(arr) => Ok(Value::from(compact_array(arr, &options))),
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Array | Kind::Object,
+                expected: Kind::array(Collection::any()) | Kind::object(Collection::any()),
             }
             .into()),
         }
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        let td = self.value.type_def(state);
-
-        if td.is_array() {
-            TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() })
+        if self.value.type_def(state).is_array() {
+            TypeDef::array(Collection::any())
         } else {
-            TypeDef::new().object::<(), Kind>(map! { (): Kind::all() })
+            TypeDef::object(Collection::any())
         }
     }
 }
@@ -396,13 +394,13 @@ mod test {
                                          "key3": "",
             ]],
             want: Ok(Value::Object(map!["key2": 1])),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         with_array {
             args: func_args![value: vec![Value::Null, Value::from(1), Value::from(""),]],
             want: Ok(Value::Array(vec![Value::from(1)])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         nullish {
@@ -415,7 +413,7 @@ mod test {
                 nullish: true
             ],
             want: Ok(Value::Object(map!["key2": 1])),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/contains.rs b/lib/vrl/stdlib/src/contains.rs
index ab072c31e9a01..fa4d2657bb832 100644
--- a/lib/vrl/stdlib/src/contains.rs
+++ b/lib/vrl/stdlib/src/contains.rs
@@ -110,7 +110,7 @@ impl Expression for ContainsFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().boolean().infallible()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -125,42 +125,42 @@ mod tests {
             args: func_args![value: value!("foo"),
                              substring: value!("bar")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         yes {
             args: func_args![value: value!("foobar"),
                              substring: value!("foo")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         entirely {
             args: func_args![value: value!("foo"),
                              substring: value!("foo")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         middle {
             args: func_args![value: value!("foobar"),
                              substring: value!("oba")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         start {
             args: func_args![value: value!("foobar"),
                              substring: value!("foo")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         end {
             args: func_args![value: value!("foobar"),
                              substring: value!("bar")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_sensitive_yes {
@@ -168,7 +168,7 @@ mod tests {
                              substring: value!("BAR"),
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
          case_sensitive_yes_lowercase {
@@ -177,7 +177,7 @@ mod tests {
                              case_sensitive: true
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_sensitive_no_uppercase {
@@ -185,7 +185,7 @@ mod tests {
                              substring: value!("BAR"),
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_insensitive_yes_uppercase {
@@ -194,7 +194,7 @@ mod tests {
                              case_sensitive: false
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().boolean().infallible(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/decode_base64.rs b/lib/vrl/stdlib/src/decode_base64.rs
index dbd277d0146f2..74e8f962bea72 100644
--- a/lib/vrl/stdlib/src/decode_base64.rs
+++ b/lib/vrl/stdlib/src/decode_base64.rs
@@ -84,7 +84,7 @@ impl Expression for DecodeBase64Fn {
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
         // Always fallible due to the possibility of decoding errors that VRL can't detect in
         // advance: https://docs.rs/base64/0.13.0/base64/enum.DecodeError.html
-        TypeDef::new().bytes().fallible()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -98,31 +98,31 @@ mod test {
         with_defaults {
             args: func_args![value: value!("c29tZSs9c3RyaW5nL3ZhbHVl")],
             want: Ok(value!("some+=string/value")),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         with_standard_charset {
             args: func_args![value: value!("c29tZSs9c3RyaW5nL3ZhbHVl"), charset: value!["standard"]],
             want: Ok(value!("some+=string/value")),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         with_urlsafe_charset {
             args: func_args![value: value!("c29tZSs9c3RyaW5nL3ZhbHVl"), charset: value!("url_safe")],
             want: Ok(value!("some+=string/value")),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         empty_string_standard_charset {
             args: func_args![value: value!(""), charset: value!("standard")],
             want: Ok(value!("")),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         empty_string_urlsafe_charset {
             args: func_args![value: value!(""), charset: value!("url_safe")],
             want: Ok(value!("")),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/decode_percent.rs b/lib/vrl/stdlib/src/decode_percent.rs
index cce2aba986b71..f799b6b4d9b49 100644
--- a/lib/vrl/stdlib/src/decode_percent.rs
+++ b/lib/vrl/stdlib/src/decode_percent.rs
@@ -53,7 +53,7 @@ impl Expression for DecodePercentFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().bytes().infallible()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -67,7 +67,7 @@ mod test {
         decode {
             args: func_args![value: value!("foo%20%23%22%3C%3E%3F%60%7B%7D%2F%3A%3B%3D%40%5B%5C%5D%5E%7C%24%25%26%2B%2C%21%27%28%29%7Ebar")],
             want: Ok(value!(r#"foo #"<>?`{}/:;=@[\]^|$%&+,!'()~bar"#)),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/del.rs b/lib/vrl/stdlib/src/del.rs
index b88fb2b68a36d..a4a7169e271a3 100644
--- a/lib/vrl/stdlib/src/del.rs
+++ b/lib/vrl/stdlib/src/del.rs
@@ -1,3 +1,4 @@
+use value::kind::remove;
 use vrl::prelude::*;
 
 fn del(
@@ -166,14 +167,27 @@ impl Expression for DelFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().unknown()
+        TypeDef::any()
     }
 
     fn update_state(
         &mut self,
         state: &mut state::Compiler,
     ) -> std::result::Result<(), ExpressionError> {
-        self.query.delete_type_def(state);
+        // FIXME(Jean): This should also delete non-external queries, as `del(foo.bar)` is
+        // supported.
+        if self.query.is_external() {
+            match self.query.delete_type_def(state) {
+                Err(remove::Error::RootPath)
+                | Err(remove::Error::CoalescedPath)
+                | Err(remove::Error::NegativeIndexPath) => {
+                    // This function is (currently) infallible, so we ignore any errors here.
+                    //
+                    // see: https://github.com/vectordotdev/vector/issues/11264
+                }
+                Ok(_) => {}
+            }
+        }
         Ok(())
     }
 }
diff --git a/lib/vrl/stdlib/src/downcase.rs b/lib/vrl/stdlib/src/downcase.rs
index bfd5e151f30e1..88d2c647e071c 100644
--- a/lib/vrl/stdlib/src/downcase.rs
+++ b/lib/vrl/stdlib/src/downcase.rs
@@ -57,7 +57,7 @@ impl Expression for DowncaseFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().bytes().infallible()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -71,7 +71,7 @@ mod tests {
         simple {
             args: func_args![value: "FOO 2 bar"],
             want: Ok(value!("foo 2 bar")),
-            tdef: TypeDef::new().bytes(),
+            tdef: TypeDef::bytes(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/encode_base64.rs b/lib/vrl/stdlib/src/encode_base64.rs
index f23ebd9a770f3..106619849353a 100644
--- a/lib/vrl/stdlib/src/encode_base64.rs
+++ b/lib/vrl/stdlib/src/encode_base64.rs
@@ -97,7 +97,7 @@ impl Expression for EncodeBase64Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().bytes().infallible()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -111,49 +111,49 @@ mod test {
         with_defaults {
             args: func_args![value: value!("some+=string/value")],
             want: Ok(value!("c29tZSs9c3RyaW5nL3ZhbHVl")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         with_padding_standard_charset {
             args: func_args![value: value!("some+=string/value"), padding: value!(true), charset: value!("standard")],
             want: Ok(value!("c29tZSs9c3RyaW5nL3ZhbHVl")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         no_padding_standard_charset {
             args: func_args![value: value!("some+=string/value"), padding: value!(false), charset: value!("standard")],
             want: Ok(value!("c29tZSs9c3RyaW5nL3ZhbHVl")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         with_padding_urlsafe_charset {
             args: func_args![value: value!("some+=string/value"), padding: value!(true), charset: value!("url_safe")],
             want: Ok(value!("c29tZSs9c3RyaW5nL3ZhbHVl")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         no_padding_urlsafe_charset {
             args: func_args![value: value!("some+=string/value"), padding: value!(false), charset: value!("url_safe")],
             want: Ok(value!("c29tZSs9c3RyaW5nL3ZhbHVl")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         empty_string_standard_charset {
             args: func_args![value: value!(""), charset: value!("standard")],
             want: Ok(value!("")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         empty_string_urlsafe_charset {
             args: func_args![value: value!(""), charset: value!("url_safe")],
             want: Ok(value!("")),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         invalid_charset_error {
             args: func_args![value: value!("some string value"), padding: value!(false), charset: value!("foo")],
             want: Err("unknown charset"),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/encode_json.rs b/lib/vrl/stdlib/src/encode_json.rs
index 9ace4b68391da..08a2613ca8b73 100644
--- a/lib/vrl/stdlib/src/encode_json.rs
+++ b/lib/vrl/stdlib/src/encode_json.rs
@@ -52,8 +52,8 @@ impl Expression for EncodeJsonFn {
         }
     }
 
-    fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value.type_def(state).infallible().bytes()
+    fn type_def(&self, _: &state::Compiler) -> TypeDef {
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -70,37 +70,37 @@ mod tests {
         bytes {
             args: func_args![value: r#"hello"#],
             want: Ok(r#""hello""#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         integer {
             args: func_args![value: 42],
             want: Ok("42"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         float {
             args: func_args![value: 42f64],
             want: Ok("42.0"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         boolean {
             args: func_args![value: false],
             want: Ok("false"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         map {
             args: func_args![value: map!["field": "value"]],
             want: Ok(r#"{"field":"value"}"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         array {
             args: func_args![value: vec![1, 2, 3]],
             want: Ok("[1,2,3]"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         timestamp {
@@ -110,20 +110,19 @@ mod tests {
                     .with_timezone(&Utc)
             ],
             want: Ok(r#""1983-04-13T12:09:14.274Z""#),
-            tdef: TypeDef::new().infallible().bytes(),
-
+            tdef: TypeDef::bytes().infallible(),
         }
 
         regex {
             args: func_args![value: Regex::new("^a\\d+$").unwrap()],
             want: Ok(r#""^a\\d+$""#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         null {
             args: func_args![value: Value::Null],
             want: Ok("null"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/encode_key_value.rs b/lib/vrl/stdlib/src/encode_key_value.rs
index af6bafa06fbbd..d6f5913e06d11 100644
--- a/lib/vrl/stdlib/src/encode_key_value.rs
+++ b/lib/vrl/stdlib/src/encode_key_value.rs
@@ -145,9 +145,7 @@ impl Expression for EncodeKeyValueFn {
     }
 
     fn type_def(&self, _state: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .bytes()
-            .with_fallibility(self.fields.is_some())
+        TypeDef::bytes().with_fallibility(self.fields.is_some())
     }
 }
 
@@ -167,7 +165,7 @@ mod tests {
                 }
             ],
             want: Ok("lvl=info"),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         multiple_elements {
@@ -178,7 +176,7 @@ mod tests {
                 }
             ],
             want: Ok("log_id=12345 lvl=info"),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         string_with_spaces {
@@ -188,7 +186,7 @@ mod tests {
                     "msg" => "This is a log message"
                 }],
             want: Ok(r#"lvl=info msg="This is a log message""#),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         flatten_boolean {
@@ -202,7 +200,7 @@ mod tests {
                 flatten_boolean: value!(true)
             ],
             want: Ok(r#"beta lvl=info msg="This is a log message""#),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         dont_flatten_boolean {
@@ -216,7 +214,7 @@ mod tests {
                 flatten_boolean: value!(false)
             ],
             want: Ok(r#"beta=true lvl=info msg="This is a log message" prod=false"#),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         flatten_boolean_with_custom_delimiters {
@@ -231,7 +229,7 @@ mod tests {
                 flatten_boolean: value!(true)
             ],
             want: Ok(r#"tag_a:val_a,tag_b:val_b,tag_c"#),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
         string_with_characters_to_escape {
             args: func_args![value:
@@ -242,7 +240,7 @@ mod tests {
                     "space key" => "foo"
                 }],
             want: Ok(r#"another_field="some\\nfield\\and things" lvl=info msg="payload: {\"code\": 200}\\n" "space key"=foo"#),
-            tdef: TypeDef::new().bytes().infallible(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         nested_fields {
@@ -264,7 +262,7 @@ mod tests {
                     "event" => "log"
                 }],
                 want: Ok("agent.id=1234 agent.name=vector event=log log.file.path=encode_key_value.rs network.ip.0=127 network.ip.1=0 network.ip.2=0 network.ip.3=1 network.proto=tcp"),
-                tdef: TypeDef::new().bytes().infallible(),
+                tdef: TypeDef::bytes().infallible(),
         }
 
         fields_ordering {
@@ -277,7 +275,7 @@ mod tests {
                 fields_ordering: value!(["lvl", "msg"])
             ],
             want: Ok(r#"lvl=info msg="This is a log message" log_id=12345"#),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         nested_fields_ordering {
@@ -296,7 +294,7 @@ mod tests {
                 fields_ordering:  value!(["event", "log.file.path", "agent.name"])
             ],
             want: Ok("event=log log.file.path=encode_key_value.rs agent.name=vector"),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         fields_ordering_invalid_field_type {
@@ -310,10 +308,10 @@ mod tests {
             ],
             want: Err(format!(r"invalid field value type at index 1: {}",
                     value::Error::Expected {
-                        got: Kind::Integer,
-                        expected: Kind::Bytes
+                        got: Kind::integer(),
+                        expected: Kind::bytes()
                     })),
-            tdef: TypeDef::new().bytes().fallible(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/encode_percent.rs b/lib/vrl/stdlib/src/encode_percent.rs
index 80076c78e927d..d50c1761f9b2f 100644
--- a/lib/vrl/stdlib/src/encode_percent.rs
+++ b/lib/vrl/stdlib/src/encode_percent.rs
@@ -137,8 +137,8 @@ impl Expression for EncodePercentFn {
         Ok(utf8_percent_encode(&string, ascii_set).to_string().into())
     }
 
-    fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value.type_def(state).infallible().bytes()
+    fn type_def(&self, _: &state::Compiler) -> TypeDef {
+        TypeDef::bytes()
     }
 }
 
@@ -152,55 +152,55 @@ mod tests {
         default {
             args: func_args![value: r#"foo bar?"#],
             want: Ok(r#"foo%20bar%3F"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         controls {
             args: func_args![value: r#"foo bar"#, ascii_set: "CONTROLS"],
             want: Ok(r#"foo %14bar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         fragment {
             args: func_args![value: r#"foo <>" `bar"#, ascii_set: "FRAGMENT"],
             want: Ok(r#"foo%20%3C%3E%22%20%60bar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         query {
             args: func_args![value: r#"foo #"<>bar"#, ascii_set: "QUERY"],
             want: Ok(r#"foo%20%23%22%3C%3Ebar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         special {
             args: func_args![value: r#"foo #"<>'bar"#, ascii_set: "SPECIAL"],
             want: Ok(r#"foo%20%23%22%3C%3E%27bar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         path {
             args: func_args![value: r#"foo #"<>?`{}bar"#, ascii_set: "PATH"],
             want: Ok(r#"foo%20%23%22%3C%3E%3F%60%7B%7Dbar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         userinfo {
             args: func_args![value: r#"foo #"<>?`{}/:;=@[\]^|bar"#, ascii_set: "USERINFO"],
             want: Ok(r#"foo%20%23%22%3C%3E%3F%60%7B%7D%2F%3A%3B%3D%40%5B%5C%5D%5E%7Cbar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         component {
             args: func_args![value: r#"foo #"<>?`{}/:;=@[\]^|$%&+,bar"#, ascii_set: "COMPONENT"],
             want: Ok(r#"foo%20%23%22%3C%3E%3F%60%7B%7D%2F%3A%3B%3D%40%5B%5C%5D%5E%7C%24%25%26%2B%2Cbar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         www_form_urlencoded {
             args: func_args![value: r#"foo #"<>?`{}/:;=@[\]^|$%&+,!'()~bar"#, ascii_set: "WWW_FORM_URLENCODED"],
             want: Ok(r#"foo%20%23%22%3C%3E%3F%60%7B%7D%2F%3A%3B%3D%40%5B%5C%5D%5E%7C%24%25%26%2B%2C%21%27%28%29%7Ebar"#),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/ends_with.rs b/lib/vrl/stdlib/src/ends_with.rs
index bb194f083c87f..8cfc768adc738 100644
--- a/lib/vrl/stdlib/src/ends_with.rs
+++ b/lib/vrl/stdlib/src/ends_with.rs
@@ -101,7 +101,7 @@ impl Expression for EndsWithFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -116,35 +116,35 @@ mod tests {
             args: func_args![value: "bar",
                              substring: "foo"],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         opposite {
             args: func_args![value: "bar",
                              substring: "foobar"],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         subset {
             args: func_args![value: "foobar",
                              substring: "oba"],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         yes {
             args: func_args![value: "foobar",
                              substring: "bar"],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         starts_with {
             args: func_args![value: "foobar",
                              substring: "foo"],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         uppercase {
@@ -152,7 +152,7 @@ mod tests {
                              substring: "BAR"
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_sensitive {
@@ -160,7 +160,7 @@ mod tests {
                              substring: "BAR"
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_insensitive {
@@ -168,7 +168,7 @@ mod tests {
                              substring: "BAR",
                              case_sensitive: false],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/exists.rs b/lib/vrl/stdlib/src/exists.rs
index 755af83d1bfb2..57ee14ee121f7 100644
--- a/lib/vrl/stdlib/src/exists.rs
+++ b/lib/vrl/stdlib/src/exists.rs
@@ -112,6 +112,6 @@ impl Expression for ExistsFn {
     }
 
     fn type_def(&self, _state: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
diff --git a/lib/vrl/stdlib/src/find.rs b/lib/vrl/stdlib/src/find.rs
index 7dbd1d13b15fe..bff9b9184108a 100644
--- a/lib/vrl/stdlib/src/find.rs
+++ b/lib/vrl/stdlib/src/find.rs
@@ -89,7 +89,7 @@ impl FindFn {
             )),
             other => Err(value::Error::Expected {
                 got: other.kind(),
-                expected: Kind::Bytes | Kind::Regex,
+                expected: Kind::bytes() | Kind::regex(),
             }
             .into()),
         }
@@ -111,7 +111,7 @@ impl Expression for FindFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().integer()
+        TypeDef::integer().infallible()
     }
 }
 
@@ -127,43 +127,43 @@ mod tests {
         str_matching_end {
             args: func_args![value: "foobar", pattern: "bar"],
             want: Ok(value!(3)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         str_matching_beginning {
             args: func_args![value: "foobar", pattern: "foo"],
             want: Ok(value!(0)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         str_matching_middle {
             args: func_args![value: "foobar", pattern: "ob"],
             want: Ok(value!(2)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         str_too_long {
             args: func_args![value: "foo", pattern: "foobar"],
             want: Ok(value!(-1)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         regex_matching_end {
             args: func_args![value: "foobar", pattern: Value::Regex(Regex::new("bar").unwrap().into())],
             want: Ok(value!(3)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         regex_matching_start {
             args: func_args![value: "foobar", pattern: Value::Regex(Regex::new("fo+z?").unwrap().into())],
             want: Ok(value!(0)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         wrong_pattern {
             args: func_args![value: "foobar", pattern: Value::Integer(42)],
-            want: Err("expected \"string\" or \"regex\", got \"integer\""),
-            tdef: TypeDef::new().infallible().integer(),
+            want: Err("expected regex or string, got integer"),
+            tdef: TypeDef::integer().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/flatten.rs b/lib/vrl/stdlib/src/flatten.rs
index 1c37e97128e3f..f4e16123a04b8 100644
--- a/lib/vrl/stdlib/src/flatten.rs
+++ b/lib/vrl/stdlib/src/flatten.rs
@@ -14,7 +14,7 @@ fn flatten(value: Value) -> Resolved {
         )),
         value => Err(value::Error::Expected {
             got: value.kind(),
-            expected: Kind::Array | Kind::Object,
+            expected: Kind::array(Collection::any()) | Kind::object(Collection::any()),
         }
         .into()),
     }
@@ -81,9 +81,9 @@ impl Expression for FlattenFn {
         let td = self.value.type_def(state);
 
         if td.is_array() {
-            TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() })
+            TypeDef::array(Collection::any())
         } else {
-            TypeDef::new().object::<(), Kind>(map! { (): Kind::all() })
+            TypeDef::object(Collection::any())
         }
     }
 }
@@ -203,43 +203,43 @@ mod test {
         array {
             args: func_args![value: value!([42])],
             want: Ok(value!([42])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         nested_array {
             args: func_args![value: value!([42, [43, 44]])],
             want: Ok(value!([42, 43, 44])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         nested_empty_array {
             args: func_args![value: value!([42, [], 43])],
             want: Ok(value!([42, 43])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         double_nested_array {
             args: func_args![value: value!([42, [43, 44, [45, 46]]])],
             want: Ok(value!([42, 43, 44, 45, 46])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         two_arrays {
             args: func_args![value: value!([[42, 43], [44, 45]])],
             want: Ok(value!([42, 43, 44, 45])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         map {
             args: func_args![value: value!({parent: "child"})],
             want: Ok(value!({parent: "child"})),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         nested_map {
             args: func_args![value: value!({parent: {child1: 1, child2: 2}, key: "val"})],
             want: Ok(value!({"parent.child1": 1, "parent.child2": 2, key: "val"})),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         double_nested_map {
@@ -256,7 +256,7 @@ mod test {
                 "parent.child2.grandchild2": 2,
                 key: "val",
             })),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         map_and_array {
@@ -273,7 +273,7 @@ mod test {
                 "parent.child2.grandchild2": [1, [2, 3], 4],
                 key: "val",
             })),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         // If the root object is an array, child maps are not flattened.
@@ -290,7 +290,7 @@ mod test {
                 { parent2: { child3: 3, child4: 4 } },
                 { parent3: { child5: 5 } },
             ])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         triple_nested_map {
@@ -307,7 +307,7 @@ mod test {
                 "parent1.child2.grandchild3": 3,
                 parent2: 4,
             })),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/float.rs b/lib/vrl/stdlib/src/float.rs
index 1d083202539be..c516c4c36d703 100644
--- a/lib/vrl/stdlib/src/float.rs
+++ b/lib/vrl/stdlib/src/float.rs
@@ -3,7 +3,7 @@ use vrl::prelude::*;
 fn float(value: Value) -> std::result::Result<Value, ExpressionError> {
     match value {
         v @ Value::Float(_) => Ok(v),
-        v => Err(format!(r#"expected "float", got {}"#, v.kind()).into()),
+        v => Err(format!("expected float, got {}", v.kind()).into()),
     }
 }
 
@@ -34,7 +34,7 @@ impl Function for Float {
                 title: "invalid",
                 source: "float!(true)",
                 result: Err(
-                    r#"function call error for "float" at (0:12): expected "float", got "boolean""#,
+                    r#"function call error for "float" at (0:12): expected float, got boolean"#,
                 ),
             },
         ]
@@ -72,9 +72,8 @@ impl Expression for FloatFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value
-            .type_def(state)
-            .fallible_unless(Kind::Float)
-            .float()
+        let non_float = !self.value.type_def(state).is_float();
+
+        TypeDef::float().with_fallibility(non_float)
     }
 }
diff --git a/lib/vrl/stdlib/src/floor.rs b/lib/vrl/stdlib/src/floor.rs
index 2418bf7a9bbe9..37e638716eb34 100644
--- a/lib/vrl/stdlib/src/floor.rs
+++ b/lib/vrl/stdlib/src/floor.rs
@@ -64,17 +64,17 @@ impl Expression for FloorFn {
             value @ Value::Integer(_) => Ok(value),
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Float | Kind::Integer,
+                expected: Kind::float() | Kind::integer(),
             }
             .into()),
         }
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        TypeDef::new().scalar(match self.value.type_def(state).kind() {
-            v if v.is_float() || v.is_integer() => v,
-            _ => Kind::Integer | Kind::Float,
-        })
+        match Kind::from(self.value.type_def(state)) {
+            v if v.is_float() || v.is_integer() => v.into(),
+            _ => Kind::integer().or_float().into(),
+        }
     }
 }
 
@@ -88,40 +88,40 @@ mod tests {
         lower {
             args: func_args![value: 1234.2],
             want: Ok(value!(1234.0)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         higher {
             args: func_args![value: 1234.8],
             want: Ok(value!(1234.0)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         exact {
             args: func_args![value: 1234],
             want: Ok(value!(1234)),
-            tdef: TypeDef::new().integer(),
+            tdef: TypeDef::integer(),
         }
 
         precision {
             args: func_args![value: 1234.39429,
                              precision: 1],
             want: Ok(value!(1234.3)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         bigger_precision {
             args: func_args![value: 1234.56789,
                              precision: 4],
             want: Ok(value!(1234.5678)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
 
         huge_number {
             args: func_args![value: 9876543210123456789098765432101234567890987654321.987654321,
                              precision: 5],
             want: Ok(value!(9876543210123456789098765432101234567890987654321.98765)),
-            tdef: TypeDef::new().float(),
+            tdef: TypeDef::float(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/format_int.rs b/lib/vrl/stdlib/src/format_int.rs
index ded6b0de21023..6405207437861 100644
--- a/lib/vrl/stdlib/src/format_int.rs
+++ b/lib/vrl/stdlib/src/format_int.rs
@@ -92,7 +92,7 @@ impl Expression for FormatIntFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().integer()
+        TypeDef::integer().fallible()
     }
 }
 
@@ -135,19 +135,19 @@ mod tests {
         decimal {
             args: func_args![value: 42],
             want: Ok(value!("42")),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         hexidecimal {
             args: func_args![value: 42, base: 16],
             want: Ok(value!("2a")),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         negative_hexidecimal {
             args: func_args![value: -42, base: 16],
             want: Ok(value!("-2a")),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/format_number.rs b/lib/vrl/stdlib/src/format_number.rs
index 762e75c17ba2e..35561d06ae980 100644
--- a/lib/vrl/stdlib/src/format_number.rs
+++ b/lib/vrl/stdlib/src/format_number.rs
@@ -78,7 +78,7 @@ impl Expression for FormatNumberFn {
             value => {
                 return Err(value::Error::Expected {
                     got: value.kind(),
-                    expected: Kind::Integer | Kind::Float,
+                    expected: Kind::integer() | Kind::float(),
                 }
                 .into())
             }
@@ -154,7 +154,7 @@ impl Expression for FormatNumberFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -168,14 +168,14 @@ mod tests {
         number {
             args: func_args![value: 1234.567],
             want: Ok(value!("1234.567")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         precision {
             args: func_args![value: 1234.567,
                              scale: 2],
             want: Ok(value!("1234.56")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
 
@@ -184,7 +184,7 @@ mod tests {
                              scale: 2,
                              decimal_separator: ","],
             want: Ok(value!("1234,56")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         more_separators {
@@ -193,7 +193,7 @@ mod tests {
                              decimal_separator: ",",
                              grouping_separator: " "],
             want: Ok(value!("1 234,56")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         big_number {
@@ -202,34 +202,34 @@ mod tests {
                              decimal_separator: ",",
                              grouping_separator: "."],
             want: Ok(value!("11.222.333.444,567")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         integer {
             args: func_args![value: 100.0],
             want: Ok(value!("100")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         integer_decimals {
             args: func_args![value: 100.0,
                              scale: 2],
             want: Ok(value!("100.00")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         float_no_decimals {
             args: func_args![value: 123.45,
                              scale: 0],
             want: Ok(value!("123")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         integer_no_decimals {
             args: func_args![value: 12345,
                              scale: 2],
             want: Ok(value!("12345.00")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/format_timestamp.rs b/lib/vrl/stdlib/src/format_timestamp.rs
index 9aed180a44000..3e0663170afe2 100644
--- a/lib/vrl/stdlib/src/format_timestamp.rs
+++ b/lib/vrl/stdlib/src/format_timestamp.rs
@@ -64,7 +64,7 @@ impl Expression for FormatTimestampFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -92,21 +92,21 @@ mod tests {
             args: func_args![value: Utc.timestamp(10, 0),
                              format: "%Q INVALID"],
             want: Err("invalid format"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         valid_secs {
             args: func_args![value: Utc.timestamp(10, 0),
                              format: "%s"],
             want: Ok(value!("10")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         date {
             args: func_args![value: Utc.timestamp(10, 0),
                              format: "%+"],
             want: Ok(value!("1970-01-01T00:00:10+00:00")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/get.rs b/lib/vrl/stdlib/src/get.rs
index 55e1a7437c55f..0a377311d003c 100644
--- a/lib/vrl/stdlib/src/get.rs
+++ b/lib/vrl/stdlib/src/get.rs
@@ -81,7 +81,7 @@ impl Function for Get {
                 title: "invalid segment type",
                 source: r#"get!(value: {"foo": { "bar": [92, 42] }}, path: ["foo", true])"#,
                 result: Err(
-                    r#"function call error for "get" at (0:62): path segment must be either "string" or "integer", not "boolean""#,
+                    r#"function call error for "get" at (0:62): path segment must be either string or integer, not boolean"#,
                 ),
             },
         ]
@@ -120,7 +120,7 @@ impl Expression for GetFn {
                         Value::Integer(index) => SegmentBuf::Index(index as isize),
                         value => {
                             return Err(format!(
-                                r#"path segment must be either "string" or "integer", not {}"#,
+                                r#"path segment must be either string or integer, not {}"#,
                                 value.kind()
                             )
                             .into())
@@ -135,7 +135,7 @@ impl Expression for GetFn {
             value => {
                 return Err(value::Error::Expected {
                     got: value.kind(),
-                    expected: Kind::Array,
+                    expected: Kind::array(Collection::any()),
                 }
                 .into())
             }
@@ -145,7 +145,7 @@ impl Expression for GetFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().unknown()
+        TypeDef::any().fallible()
     }
 }
 
@@ -159,7 +159,7 @@ mod tests {
         any {
             args: func_args![value: value!([42]), path: value!([0])],
             want: Ok(42),
-            tdef: TypeDef::new().fallible(),
+            tdef: TypeDef::any().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/get_env_var.rs b/lib/vrl/stdlib/src/get_env_var.rs
index 23d72fef77796..d07122454faf6 100644
--- a/lib/vrl/stdlib/src/get_env_var.rs
+++ b/lib/vrl/stdlib/src/get_env_var.rs
@@ -52,7 +52,7 @@ impl Expression for GetEnvVarFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -70,31 +70,31 @@ mod tests {
         doesnt_exist {
             args: func_args![name: "VAR1"],
             want: Err("environment variable not found"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         exists {
             args: func_args![name: "VAR2"],
             want: Ok(value!("var")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid1 {
             args: func_args![name: "="],
             want: Err("environment variable not found"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid2 {
             args: func_args![name: ""],
             want: Err("environment variable not found"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid3 {
             args: func_args![name: "a=b"],
             want: Err("environment variable not found"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/get_hostname.rs b/lib/vrl/stdlib/src/get_hostname.rs
index b11a070ce7fbc..29ba39d7d441c 100644
--- a/lib/vrl/stdlib/src/get_hostname.rs
+++ b/lib/vrl/stdlib/src/get_hostname.rs
@@ -38,6 +38,6 @@ impl Expression for GetHostnameFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
diff --git a/lib/vrl/stdlib/src/includes.rs b/lib/vrl/stdlib/src/includes.rs
index cb6efc9e0c2e3..33fdbdf9031ad 100644
--- a/lib/vrl/stdlib/src/includes.rs
+++ b/lib/vrl/stdlib/src/includes.rs
@@ -68,7 +68,7 @@ impl Expression for IncludesFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -82,91 +82,91 @@ mod tests {
         empty_not_included {
             args: func_args![value: value!([]), item: value!("foo")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         string_included {
             args: func_args![value: value!(["foo", "bar"]), item: value!("foo")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         string_not_included {
             args: func_args![value: value!(["foo", "bar"]), item: value!("baz")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         bool_included {
             args: func_args![value: value!([true, false]), item: value!(true)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         bool_not_included {
             args: func_args![value: value!([true, true]), item: value!(false)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer_included {
             args: func_args![value: value!([1, 2, 3, 4, 5]), item: value!(5)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer_not_included {
             args: func_args![value: value!([1, 2, 3, 4, 6]), item: value!(5)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         float_included {
             args: func_args![value: value!([0.5, 12.1, 13.075]), item: value!(13.075)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         float_not_included {
             args: func_args![value: value!([0.5, 12.1, 13.075]), item: value!(471.0)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         array_included {
             args: func_args![value: value!([[1,2,3], [4,5,6]]), item: value!([1,2,3])],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         array_not_included {
             args: func_args![value: value!([[1,2,3], [4,5,6]]), item: value!([1,2,4])],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_included_string {
             args: func_args![value: value!(["foo", 1, true, [1,2,3]]), item: value!("foo")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_not_included_string {
             args: func_args![value: value!(["bar", 1, true, [1,2,3]]), item: value!("foo")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_included_bool {
             args: func_args![value: value!(["foo", 1, true, [1,2,3]]), item: value!(true)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_not_included_bool {
             args: func_args![value: value!(["foo", 1, true, [1,2,3]]), item: value!(false)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/integer.rs b/lib/vrl/stdlib/src/integer.rs
index 5f817f2acb8bb..42120cd980e77 100644
--- a/lib/vrl/stdlib/src/integer.rs
+++ b/lib/vrl/stdlib/src/integer.rs
@@ -3,7 +3,7 @@ use vrl::prelude::*;
 fn int(value: Value) -> std::result::Result<Value, ExpressionError> {
     match value {
         v @ Value::Integer(_) => Ok(v),
-        v => Err(format!(r#"expected "integer", got {}"#, v.kind()).into()),
+        v => Err(format!(r#"expected integer, got {}"#, v.kind()).into()),
     }
 }
 
@@ -34,7 +34,7 @@ impl Function for Integer {
                 title: "invalid",
                 source: "int!(true)",
                 result: Err(
-                    r#"function call error for "int" at (0:10): expected "integer", got "boolean""#,
+                    r#"function call error for "int" at (0:10): expected integer, got boolean"#,
                 ),
             },
         ]
@@ -72,9 +72,8 @@ impl Expression for IntegerFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value
-            .type_def(state)
-            .fallible_unless(Kind::Integer)
-            .integer()
+        let non_integer = !self.value.type_def(state).is_integer();
+
+        TypeDef::integer().with_fallibility(non_integer)
     }
 }
diff --git a/lib/vrl/stdlib/src/ip_aton.rs b/lib/vrl/stdlib/src/ip_aton.rs
index 5881eb7eb9377..79aeaf423823a 100644
--- a/lib/vrl/stdlib/src/ip_aton.rs
+++ b/lib/vrl/stdlib/src/ip_aton.rs
@@ -56,7 +56,7 @@ impl Expression for IpAtonFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().integer()
+        TypeDef::integer().fallible()
     }
 }
 
@@ -70,13 +70,13 @@ mod tests {
         invalid {
             args: func_args![value: "i am not an ipaddress"],
             want: Err("unable to parse IPv4 address: invalid IP address syntax"),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         valid {
             args: func_args![value: "1.2.3.4"],
             want: Ok(value!(16909060)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/ip_cidr_contains.rs b/lib/vrl/stdlib/src/ip_cidr_contains.rs
index f8296fea61bc1..6625f30898814 100644
--- a/lib/vrl/stdlib/src/ip_cidr_contains.rs
+++ b/lib/vrl/stdlib/src/ip_cidr_contains.rs
@@ -94,7 +94,7 @@ impl Expression for IpCidrContainsFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().boolean()
+        TypeDef::boolean().fallible()
     }
 }
 
@@ -110,7 +110,7 @@ mod tests {
                              cidr: "192.168.0.0/16",
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         ipv4_no {
@@ -118,7 +118,7 @@ mod tests {
                              cidr: "192.168.0.0/24",
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         ipv6_yes {
@@ -126,7 +126,7 @@ mod tests {
                              cidr: "2001:4f8:3:ba::/64",
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         ipv6_no {
@@ -134,7 +134,7 @@ mod tests {
                              cidr: "2001:4f8:4:ba::/64",
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/ip_ntoa.rs b/lib/vrl/stdlib/src/ip_ntoa.rs
index a6f2148a91dcb..f6e2155db6268 100644
--- a/lib/vrl/stdlib/src/ip_ntoa.rs
+++ b/lib/vrl/stdlib/src/ip_ntoa.rs
@@ -56,7 +56,7 @@ impl Expression for IpNtoaFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -70,13 +70,13 @@ mod tests {
         invalid {
             args: func_args![value: u32::MAX as i64 + 1],
             want: Err("cannot convert to bytes: integer does not fit in u32"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         valid {
             args: func_args![value: 16909060],
             want: Ok(value!("1.2.3.4")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/ip_subnet.rs b/lib/vrl/stdlib/src/ip_subnet.rs
index e0946fc853e40..9b0b45cd5132e 100644
--- a/lib/vrl/stdlib/src/ip_subnet.rs
+++ b/lib/vrl/stdlib/src/ip_subnet.rs
@@ -97,7 +97,7 @@ impl Expression for IpSubnetFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -164,35 +164,35 @@ mod tests {
             args: func_args![value: "192.168.10.23",
                              subnet: "255.255.0.0"],
             want: Ok(value!("192.168.0.0")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv6 {
             args: func_args![value: "2404:6800:4003:c02::64",
                              subnet: "ff00::"],
             want: Ok(value!("2400::")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv4_subnet {
             args: func_args![value: "192.168.10.23",
                              subnet: "/16"],
             want: Ok(value!("192.168.0.0")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv4_smaller_subnet {
             args: func_args![value: "192.168.10.23",
                              subnet: "/12"],
             want: Ok(value!("192.160.0.0")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv6_subnet {
             args: func_args![value: "2404:6800:4003:c02::64",
                              subnet: "/32"],
             want: Ok(value!("2404:6800::")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/ip_to_ipv6.rs b/lib/vrl/stdlib/src/ip_to_ipv6.rs
index 68a19f1dff22a..4387d7e834db3 100644
--- a/lib/vrl/stdlib/src/ip_to_ipv6.rs
+++ b/lib/vrl/stdlib/src/ip_to_ipv6.rs
@@ -59,7 +59,7 @@ impl Expression for IpToIpv6Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -74,19 +74,19 @@ mod tests {
             args: func_args![value: "i am not an ipaddress"],
             want: Err(
                     "unable to parse IP address: invalid IP address syntax"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         valid {
             args: func_args![value: "192.168.0.1"],
             want: Ok(value!("::ffff:192.168.0.1")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv6_passthrough {
             args: func_args![value: "2404:6800:4003:c02::64"],
             want: Ok(value!("2404:6800:4003:c02::64")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/ipv6_to_ipv4.rs b/lib/vrl/stdlib/src/ipv6_to_ipv4.rs
index d3f2bc447819f..69946b32a358f 100644
--- a/lib/vrl/stdlib/src/ipv6_to_ipv4.rs
+++ b/lib/vrl/stdlib/src/ipv6_to_ipv4.rs
@@ -62,7 +62,7 @@ impl Expression for Ipv6ToIpV4Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -76,31 +76,31 @@ mod tests {
         error {
             args: func_args![value: "i am not an ipaddress"],
             want: Err(r#"unable to parse IP address: invalid IP address syntax"#.to_string()),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         incompatible {
             args: func_args![value: "2001:0db8:85a3::8a2e:0370:7334"],
             want: Err("IPV6 address 2001:db8:85a3::8a2e:370:7334 is not compatible with IPV4".to_string()),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv4_compatible {
             args: func_args![value: "::ffff:192.168.0.1"],
             want: Ok(Value::from("192.168.0.1")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv6 {
             args: func_args![value: "0:0:0:0:0:ffff:c633:6410"],
             want: Ok(Value::from("198.51.100.16")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ipv4 {
             args: func_args![value: "198.51.100.16"],
             want: Ok(Value::from("198.51.100.16")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_array.rs b/lib/vrl/stdlib/src/is_array.rs
index 96734ddf08a12..785c14716e407 100644
--- a/lib/vrl/stdlib/src/is_array.rs
+++ b/lib/vrl/stdlib/src/is_array.rs
@@ -63,7 +63,7 @@ impl Expression for IsArrayFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         array {
             args: func_args![value: value!([1, 2, 3])],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer {
             args: func_args![value: value!(1789)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_boolean.rs b/lib/vrl/stdlib/src/is_boolean.rs
index 4e6c23b5fe076..100cd0936ef10 100644
--- a/lib/vrl/stdlib/src/is_boolean.rs
+++ b/lib/vrl/stdlib/src/is_boolean.rs
@@ -63,7 +63,7 @@ impl Expression for IsBooleanFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         bytes {
             args: func_args![value: value!("foobar")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         array {
             args: func_args![value: value!(false)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_float.rs b/lib/vrl/stdlib/src/is_float.rs
index 00eda529d2d47..5e6493df1e480 100644
--- a/lib/vrl/stdlib/src/is_float.rs
+++ b/lib/vrl/stdlib/src/is_float.rs
@@ -63,7 +63,7 @@ impl Expression for IsFloatFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         bytes {
             args: func_args![value: value!("foobar")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         float {
             args: func_args![value: value!(0.577)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_integer.rs b/lib/vrl/stdlib/src/is_integer.rs
index 70fc21cf03c63..7be70b858183a 100644
--- a/lib/vrl/stdlib/src/is_integer.rs
+++ b/lib/vrl/stdlib/src/is_integer.rs
@@ -63,7 +63,7 @@ impl Expression for IsIntegerFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         bytes {
             args: func_args![value: value!("foobar")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer {
             args: func_args![value: value!(1789)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_null.rs b/lib/vrl/stdlib/src/is_null.rs
index a3d7cb014dc35..66e984d080612 100644
--- a/lib/vrl/stdlib/src/is_null.rs
+++ b/lib/vrl/stdlib/src/is_null.rs
@@ -63,7 +63,7 @@ impl Expression for IsNullFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         array {
             args: func_args![value: value!(null)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer {
             args: func_args![value: value!(1789)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_nullish.rs b/lib/vrl/stdlib/src/is_nullish.rs
index d53679737151f..c9af019a70b5e 100644
--- a/lib/vrl/stdlib/src/is_nullish.rs
+++ b/lib/vrl/stdlib/src/is_nullish.rs
@@ -49,7 +49,7 @@ impl Expression for IsNullishFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -62,63 +62,63 @@ mod tests {
         empty_string {
             args: func_args![value: value!("")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         single_space_string {
             args: func_args![value: value!(" ")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         multi_space_string {
             args: func_args![value: value!("     ")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         newline_string {
             args: func_args![value: value!("\n")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         carriage_return_string {
             args: func_args![value: value!("\r")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         dash_string {
             args: func_args![value: value!("-")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         null {
             args: func_args![value: value!(null)],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         non_empty_string {
             args: func_args![value: value!("hello world")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         // Shows that a non-string/null literal returns false
         integer {
             args: func_args![value: value!(427)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         // Shows that a non-literal type returns false
         array {
             args: func_args![value: value!([1, 2, 3])],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_object.rs b/lib/vrl/stdlib/src/is_object.rs
index 2b5f454d94f05..08d4884088ef5 100644
--- a/lib/vrl/stdlib/src/is_object.rs
+++ b/lib/vrl/stdlib/src/is_object.rs
@@ -63,7 +63,7 @@ impl Expression for IsObjectFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         bytes {
             args: func_args![value: value!("foobar")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         object {
             args: func_args![value: value!({"foo": "bar"})],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_regex.rs b/lib/vrl/stdlib/src/is_regex.rs
index 1387ec0cbe6c0..870269db5b651 100644
--- a/lib/vrl/stdlib/src/is_regex.rs
+++ b/lib/vrl/stdlib/src/is_regex.rs
@@ -63,7 +63,7 @@ impl Expression for IsRegexFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -79,13 +79,13 @@ mod tests {
         bytes {
             args: func_args![value: value!("foobar")],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         regex {
             args: func_args![value: value!(Regex::new(r"\d+").unwrap())],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_string.rs b/lib/vrl/stdlib/src/is_string.rs
index b2fda37b6a618..490800beaa56a 100644
--- a/lib/vrl/stdlib/src/is_string.rs
+++ b/lib/vrl/stdlib/src/is_string.rs
@@ -63,7 +63,7 @@ impl Expression for IsStringFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         bytes {
             args: func_args![value: value!("foobar")],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer {
             args: func_args![value: value!(1789)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/is_timestamp.rs b/lib/vrl/stdlib/src/is_timestamp.rs
index 3aa38155357ff..de34ab12a577a 100644
--- a/lib/vrl/stdlib/src/is_timestamp.rs
+++ b/lib/vrl/stdlib/src/is_timestamp.rs
@@ -63,7 +63,7 @@ impl Expression for IsTimestampFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -81,13 +81,13 @@ mod tests {
                 .unwrap()
                 .with_timezone(&Utc))],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         integer {
             args: func_args![value: value!(1789)],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/join.rs b/lib/vrl/stdlib/src/join.rs
index a018e815bc457..905f462ce3d9c 100644
--- a/lib/vrl/stdlib/src/join.rs
+++ b/lib/vrl/stdlib/src/join.rs
@@ -79,7 +79,7 @@ impl Expression for JoinFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -92,25 +92,25 @@ mod test {
         with_comma_separator {
             args: func_args![value: value!(["one", "two", "three"]), separator: ", "],
             want: Ok(value!("one, two, three")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         with_space_separator {
             args: func_args![value: value!(["one", "two", "three"]), separator: " "],
             want: Ok(value!("one two three")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         without_separator {
             args: func_args![value: value!(["one", "two", "three"])],
             want: Ok(value!("onetwothree")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         non_string_array_item_throws_error {
             args: func_args![value: value!(["one", "two", 3])],
             want: Err("all array items must be strings"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/length.rs b/lib/vrl/stdlib/src/length.rs
index 38739abb05902..fb5b5d742445a 100644
--- a/lib/vrl/stdlib/src/length.rs
+++ b/lib/vrl/stdlib/src/length.rs
@@ -65,14 +65,16 @@ impl Expression for LengthFn {
             Bytes(v) => Ok(v.len().into()),
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Array | Kind::Object | Kind::Bytes,
+                expected: Kind::array(Collection::any())
+                    | Kind::object(Collection::any())
+                    | Kind::bytes(),
             }
             .into()),
         }
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().integer()
+        TypeDef::integer().infallible()
     }
 }
 
@@ -86,37 +88,37 @@ mod tests {
         non_empty_object_value {
             args: func_args![value: value!({"foo": "bar", "baz": true, "baq": [1, 2, 3]})],
             want: Ok(value!(3)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         empty_object_value {
             args: func_args![value: value!({})],
             want: Ok(value!(0)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         nested_object_value {
             args: func_args![value: value!({"nested": {"foo": "bar"}})],
             want: Ok(value!(1)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         non_empty_array_value {
             args: func_args![value: value!([1, 2, 3, 4, true, "hello"])],
             want: Ok(value!(6)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         empty_array_value {
             args: func_args![value: value!([])],
             want: Ok(value!(0)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         string_value {
             args: func_args![value: value!("hello world")],
             want: Ok(value!(11)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/log.rs b/lib/vrl/stdlib/src/log.rs
index 561d9694ee0e0..bcc90047a65e2 100644
--- a/lib/vrl/stdlib/src/log.rs
+++ b/lib/vrl/stdlib/src/log.rs
@@ -183,7 +183,7 @@ impl Expression for LogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().null()
+        TypeDef::null().infallible()
     }
 }
 
@@ -199,7 +199,7 @@ mod tests {
                                level: value!("warn"),
                                rate_limit_secs: value!(5) ],
             want: Ok(Value::Null),
-            tdef: TypeDef::new().infallible().null(),
+            tdef: TypeDef::null().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/match.rs b/lib/vrl/stdlib/src/match.rs
index bd3c10b198db7..d77fbffa22024 100644
--- a/lib/vrl/stdlib/src/match.rs
+++ b/lib/vrl/stdlib/src/match.rs
@@ -68,7 +68,7 @@ impl Expression for MatchFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -86,14 +86,14 @@ mod tests {
             args: func_args![value: "foobar",
                              pattern: Value::Regex(Regex::new("\\s\\w+").unwrap().into())],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         no {
             args: func_args![value: "foo 2 bar",
                              pattern: Value::Regex(Regex::new("foo \\d bar").unwrap().into())],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/match_any.rs b/lib/vrl/stdlib/src/match_any.rs
index 4858062f63290..19847257a7077 100644
--- a/lib/vrl/stdlib/src/match_any.rs
+++ b/lib/vrl/stdlib/src/match_any.rs
@@ -84,7 +84,7 @@ impl Expression for MatchAnyFn {
     }
 
     fn type_def(&self, _state: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -106,7 +106,7 @@ mod tests {
                                  Value::Regex(Regex::new("baz").unwrap().into()),
                              ])],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         no {
@@ -116,7 +116,7 @@ mod tests {
                                  Value::Regex(Regex::new("foobar").unwrap().into()),
                              ])],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/match_array.rs b/lib/vrl/stdlib/src/match_array.rs
index bfa37550e38cd..5de1b48789287 100644
--- a/lib/vrl/stdlib/src/match_array.rs
+++ b/lib/vrl/stdlib/src/match_array.rs
@@ -93,7 +93,7 @@ impl Expression for MatchArrayFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -113,7 +113,7 @@ mod tests {
                 pattern: Value::Regex(Regex::new("foo").unwrap().into())
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         all {
@@ -123,7 +123,7 @@ mod tests {
                 all: value!(true),
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         not_all {
@@ -133,7 +133,7 @@ mod tests {
                 all: value!(true),
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_values {
@@ -142,7 +142,7 @@ mod tests {
                 pattern: Value::Regex(Regex::new("abc").unwrap().into())
             ],
             want: Ok(value!(true)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_values_no_match {
@@ -151,7 +151,7 @@ mod tests {
                 pattern: Value::Regex(Regex::new("xyz").unwrap().into()),
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         mixed_values_no_match_all {
@@ -161,7 +161,7 @@ mod tests {
                 all: value!(true),
             ],
             want: Ok(value!(false)),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/match_datadog_query.rs b/lib/vrl/stdlib/src/match_datadog_query.rs
index 2a8e69e9f99d5..fd85f6917cec7 100644
--- a/lib/vrl/stdlib/src/match_datadog_query.rs
+++ b/lib/vrl/stdlib/src/match_datadog_query.rs
@@ -157,7 +157,7 @@ impl Expression for MatchDatadogQueryFn {
 }
 
 fn type_def() -> TypeDef {
-    TypeDef::new().infallible().boolean()
+    TypeDef::boolean().infallible()
 }
 
 #[derive(Default, Clone)]
diff --git a/lib/vrl/stdlib/src/md5.rs b/lib/vrl/stdlib/src/md5.rs
index c9cfc4a469ab0..2e6ee8171faa8 100644
--- a/lib/vrl/stdlib/src/md5.rs
+++ b/lib/vrl/stdlib/src/md5.rs
@@ -50,7 +50,7 @@ impl Expression for Md5Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -64,7 +64,7 @@ mod tests {
         md5 {
             args: func_args![value: "foo"],
             want: Ok(value!("acbd18db4cc2f85cedef654fccc4a4d8")),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/merge.rs b/lib/vrl/stdlib/src/merge.rs
index 4856a2c705b45..bbfb271b06bab 100644
--- a/lib/vrl/stdlib/src/merge.rs
+++ b/lib/vrl/stdlib/src/merge.rs
@@ -129,6 +129,7 @@ where
 #[cfg(test)]
 mod tests {
     use value::Kind;
+    use vector_common::btreemap;
 
     use super::*;
 
@@ -141,9 +142,9 @@ mod tests {
                 from: value!({ key2: "val2" })
             ],
             want: Ok(value!({ key1: "val1", key2: "val2" })),
-            tdef: TypeDef::new().object::<String, TypeDef>(map! {
-                "key1": Kind::Bytes,
-                "key2": Kind::Bytes,
+            tdef: TypeDef::object(btreemap! {
+                Field::from("key1") => Kind::bytes(),
+                Field::from("key2") => Kind::bytes(),
             }),
         }
 
@@ -163,11 +164,11 @@ mod tests {
                 key2: "val2",
                 child: { grandchild2: true },
             })),
-            tdef: TypeDef::new().object::<String, TypeDef>(map! {
-                "key1": Kind::Bytes,
-                "key2": Kind::Bytes,
-                "child": TypeDef::new().object::<String, TypeDef>(map! {
-                    "grandchild2": Kind::Boolean,
+            tdef: TypeDef::object(btreemap! {
+                Field::from("key1") => Kind::bytes(),
+                Field::from("key2") => Kind::bytes(),
+                Field::from("child") => TypeDef::object(btreemap! {
+                    Field::from("grandchild2") => Kind::boolean(),
                 }),
             }),
         }
@@ -192,11 +193,11 @@ mod tests {
                     grandchild2: true,
                 },
             })),
-            tdef: TypeDef::new().object::<String, TypeDef>(map! {
-                "key1": Kind::Bytes,
-                "key2": Kind::Bytes,
-                "child": TypeDef::new().object::<String, TypeDef>(map! {
-                    "grandchild2": Kind::Boolean,
+            tdef: TypeDef::object(btreemap! {
+                Field::from("key1") => Kind::bytes(),
+                Field::from("key2") => Kind::bytes(),
+                Field::from("child") => TypeDef::object(btreemap! {
+                    Field::from("grandchild2") => Kind::boolean(),
                 }),
             }),
 
diff --git a/lib/vrl/stdlib/src/now.rs b/lib/vrl/stdlib/src/now.rs
index adf98ccccdd74..2caf837df95b2 100644
--- a/lib/vrl/stdlib/src/now.rs
+++ b/lib/vrl/stdlib/src/now.rs
@@ -40,6 +40,6 @@ impl Expression for NowFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().timestamp()
+        TypeDef::timestamp()
     }
 }
diff --git a/lib/vrl/stdlib/src/object.rs b/lib/vrl/stdlib/src/object.rs
index aaa41a01cb7b8..aeb04626aad51 100644
--- a/lib/vrl/stdlib/src/object.rs
+++ b/lib/vrl/stdlib/src/object.rs
@@ -3,7 +3,7 @@ use vrl::prelude::*;
 fn object(value: Value) -> std::result::Result<Value, ExpressionError> {
     match value {
         v @ Value::Object(_) => Ok(v),
-        v => Err(format!(r#"expected "object", got {}"#, v.kind()).into()),
+        v => Err(format!("expected object, got {}", v.kind()).into()),
     }
 }
 
@@ -34,7 +34,7 @@ impl Function for Object {
                 title: "invalid",
                 source: "object!(true)",
                 result: Err(
-                    r#"function call error for "object" at (0:13): expected "object", got "boolean""#,
+                    r#"function call error for "object" at (0:13): expected object, got boolean"#,
                 ),
             },
         ]
@@ -74,7 +74,7 @@ impl Expression for ObjectFn {
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
         self.value
             .type_def(state)
-            .fallible_unless(Kind::Object)
+            .fallible_unless(Kind::object(Collection::any()))
             .restrict_object()
     }
 }
diff --git a/lib/vrl/stdlib/src/only_fields.rs b/lib/vrl/stdlib/src/only_fields.rs
index 8ec9d3738baf2..f6e834ff094ff 100644
--- a/lib/vrl/stdlib/src/only_fields.rs
+++ b/lib/vrl/stdlib/src/only_fields.rs
@@ -59,7 +59,7 @@ impl Expression for OnlyFieldsFn {
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
         TypeDef {
             fallible: true,
-            kind: value::Kind::Null,
+            kind: value::Kind::null(),
             ..Default::default()
         }
     }
@@ -75,7 +75,7 @@ mod tests {
         },
         def: TypeDef {
             fallible: true,
-            kind: value::Kind::Null,
+            kind: value::Kind::null(),
             ..Default::default()
         },
     }];
diff --git a/lib/vrl/stdlib/src/parse_apache_log.rs b/lib/vrl/stdlib/src/parse_apache_log.rs
index e8f01d4eef913..16f9c26d75207 100644
--- a/lib/vrl/stdlib/src/parse_apache_log.rs
+++ b/lib/vrl/stdlib/src/parse_apache_log.rs
@@ -117,58 +117,66 @@ impl Expression for ParseApacheLogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible()
-            .object(match self.format.as_ref() {
-                b"common" => type_def_common(),
-                b"combined" => type_def_combined(),
-                b"error" => type_def_error(),
-                _ => unreachable!(),
-            })
+        TypeDef::object(match self.format.as_ref() {
+            b"common" => kind_common(),
+            b"combined" => kind_combined(),
+            b"error" => kind_error(),
+            _ => unreachable!(),
+        })
+        .fallible()
     }
 }
 
-fn type_def_common() -> BTreeMap<&'static str, TypeDef> {
+fn kind_common() -> BTreeMap<Field, Kind> {
     map! {
-         "host": Kind::Bytes | Kind::Null,
-         "identity": Kind::Bytes | Kind::Null,
-         "user": Kind::Bytes | Kind::Null,
-         "timestamp": Kind::Timestamp | Kind::Null,
-         "message": Kind::Bytes | Kind::Null,
-         "method": Kind::Bytes | Kind::Null,
-         "path": Kind::Bytes | Kind::Null,
-         "protocol": Kind::Bytes | Kind::Null,
-         "status": Kind::Integer | Kind::Null,
-         "size": Kind::Integer | Kind::Null,
+         "host": Kind::bytes() | Kind::null(),
+         "identity": Kind::bytes() | Kind::null(),
+         "user": Kind::bytes() | Kind::null(),
+         "timestamp": Kind::timestamp() | Kind::null(),
+         "message": Kind::bytes() | Kind::null(),
+         "method": Kind::bytes() | Kind::null(),
+         "path": Kind::bytes() | Kind::null(),
+         "protocol": Kind::bytes() | Kind::null(),
+         "status": Kind::integer() | Kind::null(),
+         "size": Kind::integer() | Kind::null(),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
-fn type_def_combined() -> BTreeMap<&'static str, TypeDef> {
+fn kind_combined() -> BTreeMap<Field, Kind> {
     map! {
-        "host": Kind::Bytes | Kind::Null,
-        "identity": Kind::Bytes | Kind::Null,
-        "user": Kind::Bytes | Kind::Null,
-        "timestamp": Kind::Timestamp | Kind::Null,
-        "message": Kind::Bytes | Kind::Null,
-        "method": Kind::Bytes | Kind::Null,
-        "path": Kind::Bytes | Kind::Null,
-        "protocol": Kind::Bytes | Kind::Null,
-        "status": Kind::Integer | Kind::Null,
-        "size": Kind::Integer | Kind::Null,
-        "referrer": Kind::Bytes | Kind::Null,
-        "agent": Kind::Bytes | Kind::Null,
+        "host": Kind::bytes() | Kind::null(),
+        "identity": Kind::bytes() | Kind::null(),
+        "user": Kind::bytes() | Kind::null(),
+        "timestamp": Kind::timestamp() | Kind::null(),
+        "message": Kind::bytes() | Kind::null(),
+        "method": Kind::bytes() | Kind::null(),
+        "path": Kind::bytes() | Kind::null(),
+        "protocol": Kind::bytes() | Kind::null(),
+        "status": Kind::integer() | Kind::null(),
+        "size": Kind::integer() | Kind::null(),
+        "referrer": Kind::bytes() | Kind::null(),
+        "agent": Kind::bytes() | Kind::null(),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
-fn type_def_error() -> BTreeMap<&'static str, TypeDef> {
+fn kind_error() -> BTreeMap<Field, Kind> {
     map! {
-         "timestamp": Kind::Timestamp | Kind::Null,
-         "module": Kind::Bytes | Kind::Null,
-         "severity": Kind::Bytes | Kind::Null,
-         "thread": Kind::Bytes | Kind::Null,
-         "port": Kind::Bytes | Kind::Null,
-         "message": Kind::Bytes | Kind::Null,
+         "timestamp": Kind::timestamp() | Kind::null(),
+         "module": Kind::bytes() | Kind::null(),
+         "severity": Kind::bytes() | Kind::null(),
+         "thread": Kind::bytes() | Kind::null(),
+         "port": Kind::bytes() | Kind::null(),
+         "message": Kind::bytes() | Kind::null(),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
 #[cfg(test)]
@@ -197,7 +205,7 @@ mod tests {
                 "status" => 200,
                 "size" => 2326,
             }),
-            tdef: TypeDef::new().fallible().object(type_def_common()),
+            tdef: TypeDef::object(kind_common()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -219,7 +227,7 @@ mod tests {
                 "referrer" => "http://www.seniorinfomediaries.com/vertical/channels/front-end/bandwidth",
                 "agent" => "Mozilla/5.0 (X11; Linux i686; rv:5.0) Gecko/1945-10-12 Firefox/37.0",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_combined()),
+            tdef: TypeDef::object(kind_combined()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -239,7 +247,7 @@ mod tests {
                 "status" => 401,
                 "size" => 84170,
             }),
-            tdef: TypeDef::new().fallible().object(type_def_combined()),
+            tdef: TypeDef::object(kind_combined()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -257,7 +265,7 @@ mod tests {
                 "client" => "147.159.108.175",
                 "port" => 24259
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -275,7 +283,7 @@ mod tests {
                 "client" => "eda7:35d:3ceb:ef1e:2133:e7bf:116e:24cc",
                 "port" => 24259
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -295,7 +303,7 @@ mod tests {
                 "port" => 35106
 
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
             tz: vector_common::TimeZone::Named(chrono_tz::Tz::UTC),
         }
 
@@ -304,7 +312,7 @@ mod tests {
                              format: "common",
             ],
             want: Ok(btreemap! {}),
-            tdef: TypeDef::new().fallible().object(type_def_common()),
+            tdef: TypeDef::object(kind_common()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -313,7 +321,7 @@ mod tests {
                              format: "common",
             ],
             want: Ok(btreemap! {}),
-            tdef: TypeDef::new().fallible().object(type_def_common()),
+            tdef: TypeDef::object(kind_common()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -329,7 +337,7 @@ mod tests {
             want: Ok(btreemap! {
                 "timestamp" => Value::Timestamp(DateTime::parse_from_rfc3339("2000-10-10T20:55:36Z").unwrap().into()),
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -342,7 +350,7 @@ mod tests {
             want: Ok(btreemap! {
                 "timestamp" => Value::Timestamp(DateTime::parse_from_rfc3339("2021-06-03T07:30:50Z").unwrap().into()),
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
             tz: vector_common::TimeZone::Named(chrono_tz::Europe::Paris),
         }
 
@@ -351,7 +359,7 @@ mod tests {
                              format: "common",
             ],
             want: Err("failed parsing common log line"),
-            tdef: TypeDef::new().fallible().object(type_def_common()),
+            tdef: TypeDef::object(kind_common()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -360,7 +368,7 @@ mod tests {
                              format: "combined",
             ],
             want: Err("failed parsing timestamp 1234 using format %d/%b/%Y:%T %z: input contains invalid characters"),
-            tdef: TypeDef::new().fallible().object(type_def_combined()),
+            tdef: TypeDef::object(kind_combined()).fallible(),
             tz: vector_common::TimeZone::default(),
         }
     ];
diff --git a/lib/vrl/stdlib/src/parse_aws_alb_log.rs b/lib/vrl/stdlib/src/parse_aws_alb_log.rs
index 2c064384707c2..326677e7f2eb1 100644
--- a/lib/vrl/stdlib/src/parse_aws_alb_log.rs
+++ b/lib/vrl/stdlib/src/parse_aws_alb_log.rs
@@ -67,46 +67,47 @@ impl Expression for ParseAwsAlbLogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible() // Log parsing error
-            .object::<&str, Kind>(inner_type_def())
+        TypeDef::object(inner_kind()).fallible(/* log parsing error */)
     }
 }
 
-fn inner_type_def() -> BTreeMap<&'static str, Kind> {
+fn inner_kind() -> BTreeMap<Field, Kind> {
     map! {
-        "actions_executed": Kind::Bytes | Kind::Null,
-        "chosen_cert_arn": Kind::Bytes | Kind::Null,
-        "classification_reason": Kind::Bytes | Kind::Null,
-        "classification": Kind::Bytes | Kind::Null,
-        "client_host": Kind::Bytes,
-        "domain_name": Kind::Bytes | Kind::Null,
-        "elb_status_code": Kind::Bytes,
-        "elb": Kind::Bytes,
-        "error_reason": Kind::Bytes | Kind::Null,
-        "matched_rule_priority": Kind::Bytes | Kind::Null,
-        "received_bytes": Kind::Integer,
-        "redirect_url": Kind::Bytes | Kind::Null,
-        "request_creation_time": Kind::Bytes,
-        "request_method": Kind::Bytes,
-        "request_processing_time": Kind::Float,
-        "request_protocol": Kind::Bytes,
-        "request_url": Kind::Bytes,
-        "response_processing_time": Kind::Float,
-        "sent_bytes": Kind::Integer,
-        "ssl_cipher": Kind::Bytes | Kind::Null,
-        "ssl_protocol": Kind::Bytes | Kind::Null,
-        "target_group_arn": Kind::Bytes,
-        "target_host": Kind::Bytes | Kind::Null,
-        "target_port_list": Kind::Bytes | Kind::Null,
-        "target_processing_time": Kind::Float,
-        "target_status_code_list": Kind::Bytes | Kind::Null,
-        "target_status_code": Kind::Bytes | Kind::Null,
-        "timestamp": Kind::Bytes,
-        "trace_id": Kind::Bytes,
-        "type": Kind::Bytes,
-        "user_agent": Kind::Bytes,
+        "actions_executed": Kind::bytes() | Kind::null(),
+        "chosen_cert_arn": Kind::bytes() | Kind::null(),
+        "classification_reason": Kind::bytes() | Kind::null(),
+        "classification": Kind::bytes() | Kind::null(),
+        "client_host": Kind::bytes(),
+        "domain_name": Kind::bytes() | Kind::null(),
+        "elb_status_code": Kind::bytes(),
+        "elb": Kind::bytes(),
+        "error_reason": Kind::bytes() | Kind::null(),
+        "matched_rule_priority": Kind::bytes() | Kind::null(),
+        "received_bytes": Kind::integer(),
+        "redirect_url": Kind::bytes() | Kind::null(),
+        "request_creation_time": Kind::bytes(),
+        "request_method": Kind::bytes(),
+        "request_processing_time": Kind::float(),
+        "request_protocol": Kind::bytes(),
+        "request_url": Kind::bytes(),
+        "response_processing_time": Kind::float(),
+        "sent_bytes": Kind::integer(),
+        "ssl_cipher": Kind::bytes() | Kind::null(),
+        "ssl_protocol": Kind::bytes() | Kind::null(),
+        "target_group_arn": Kind::bytes(),
+        "target_host": Kind::bytes() | Kind::null(),
+        "target_port_list": Kind::bytes() | Kind::null(),
+        "target_processing_time": Kind::float(),
+        "target_status_code_list": Kind::bytes() | Kind::null(),
+        "target_status_code": Kind::bytes() | Kind::null(),
+        "timestamp": Kind::bytes(),
+        "trace_id": Kind::bytes(),
+        "type": Kind::bytes(),
+        "user_agent": Kind::bytes(),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
 fn parse_log(mut input: &str) -> Result<Value> {
@@ -303,7 +304,7 @@ mod tests {
                              user_agent: "curl/7.46.0"
 
             })),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         two {
@@ -339,7 +340,7 @@ mod tests {
                               trace_id: "Root=1-58337281-1d84f3d73c47ec4e58577259",
                               type: "https",
                               user_agent: "curl/7.46.0"})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         three {
@@ -375,7 +376,7 @@ mod tests {
                               trace_id: "Root=1-58337327-72bd00b0343d75b906739c42",
                               type: "h2",
                               user_agent: "curl/7.46.0"})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         four {
@@ -411,7 +412,7 @@ mod tests {
                              trace_id: "Root=1-58337364-23a8c76965a2ef7629b185e3",
                              type: "ws",
                              user_agent: null})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         five {
@@ -447,7 +448,7 @@ mod tests {
                               trace_id: "Root=1-58337364-23a8c76965a2ef7629b185e3",
                               type: "wss",
                               user_agent: null})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         six {
@@ -483,7 +484,7 @@ mod tests {
                               trace_id: "Root=1-58337364-23a8c76965a2ef7629b185e3",
                               type: "http",
                               user_agent: "curl/7.46.0"})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         seven {
@@ -519,7 +520,7 @@ mod tests {
                              trace_id: "Root=1-58337364-23a8c76965a2ef7629b185e3",
                              type: "http",
                              user_agent: "curl/7.46.0"})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         eight {
@@ -555,7 +556,7 @@ mod tests {
                              target_status_code_list: ["200"],
                              classification: null,
                              classification_reason: null})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         nine {
@@ -591,7 +592,7 @@ mod tests {
                              target_status_code_list: [],
                              classification: null,
                              classification_reason: null})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         ten {
@@ -627,7 +628,7 @@ mod tests {
                              target_status_code_list: [],
                              classification: null,
                              classification_reason: null})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         eleven {
@@ -663,7 +664,7 @@ mod tests {
                              target_status_code_list: ["200"],
                              classification: null,
                              classification_reason: null})),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_aws_cloudwatch_log_subscription_message.rs b/lib/vrl/stdlib/src/parse_aws_cloudwatch_log_subscription_message.rs
index d6b1dfedb5fb7..7a38134adc2bd 100644
--- a/lib/vrl/stdlib/src/parse_aws_cloudwatch_log_subscription_message.rs
+++ b/lib/vrl/stdlib/src/parse_aws_cloudwatch_log_subscription_message.rs
@@ -97,27 +97,30 @@ impl Expression for ParseAwsCloudWatchLogSubscriptionMessageFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible() // Message parsing error
-            .object::<&str, TypeDef>(inner_type_def())
+        TypeDef::object(inner_kind()).fallible(/* message parsing error */)
     }
 }
 
-fn inner_type_def() -> BTreeMap<&'static str, TypeDef> {
+fn inner_kind() -> BTreeMap<Field, Kind> {
     map! {
-        "owner": Kind::Bytes,
-        "message_type": Kind::Bytes,
-        "log_group": Kind::Bytes,
-        "log_stream": Kind::Bytes,
-        "subscription_filters": TypeDef::new().array_mapped::<(), Kind>(map! {
-            (): Kind::Bytes
-        }),
-        "log_events": TypeDef::new().object::<&str, Kind>(map! {
-            "id": Kind::Bytes,
-            "timestamp": Kind::Timestamp,
-            "message": Kind::Bytes,
+        "owner": Kind::bytes(),
+        "message_type": Kind::bytes(),
+        "log_group": Kind::bytes(),
+        "log_stream": Kind::bytes(),
+        "subscription_filters": Kind::array({
+            let mut v = Collection::any();
+            v.set_unknown(Kind::bytes());
+            v
         }),
+        "log_events": Kind::object(BTreeMap::from([
+            ("id".into(), Kind::bytes()),
+            ("timestamp".into(), Kind::timestamp()),
+            ("message".into(), Kind::bytes()),
+        ])),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
 #[cfg(test)]
@@ -132,7 +135,7 @@ mod tests {
         invalid_type {
             args: func_args![value: "42"],
             want: Err("unable to parse: invalid type: integer `42`, expected struct AwsCloudWatchLogsSubscriptionMessage at line 1 column 2"),
-            tdef: TypeDef::new().fallible().object::<&str, TypeDef>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         string {
@@ -175,13 +178,13 @@ mod tests {
                     "message": "{\"bytes\":17707,\"datetime\":\"14/Sep/2020:11:45:41 -0400\",\"host\":\"109.81.244.252\",\"method\":\"GET\",\"protocol\":\"HTTP/2.0\",\"referer\":\"http://www.investormission-critical.io/24/7/vortals\",\"request\":\"/scale/functionalities/optimize\",\"source_type\":\"stdin\",\"status\":502,\"user-identifier\":\"feeney1708\"}",
                 ]],
             ]),
-            tdef: TypeDef::new().fallible().object::<&str, TypeDef>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         invalid_value {
             args: func_args![value: r#"{ INVALID }"#],
             want: Err("unable to parse: key must be a string at line 1 column 3"),
-            tdef: TypeDef::new().fallible().object::<&str, TypeDef>(inner_type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_aws_vpc_flow_log.rs b/lib/vrl/stdlib/src/parse_aws_vpc_flow_log.rs
index 4e6f4392a1f70..d122322b88825 100644
--- a/lib/vrl/stdlib/src/parse_aws_vpc_flow_log.rs
+++ b/lib/vrl/stdlib/src/parse_aws_vpc_flow_log.rs
@@ -102,40 +102,41 @@ impl Expression for ParseAwsVpcFlowLogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible() // Log parsing error
-            .object::<&str, Kind>(inner_type_def())
+        TypeDef::object(inner_kind()).fallible(/* log parsing error */)
     }
 }
 
-fn inner_type_def() -> BTreeMap<&'static str, Kind> {
+fn inner_kind() -> BTreeMap<Field, Kind> {
     map! {
-        "account_id": Kind::Integer | Kind::Null,
-        "action": Kind::Bytes | Kind::Null,
-        "az_id": Kind::Bytes | Kind::Null,
-        "bytes": Kind::Integer | Kind::Null,
-        "dstaddr": Kind::Bytes | Kind::Null,
-        "dstport": Kind::Integer | Kind::Null,
-        "end": Kind::Integer | Kind::Null,
-        "instance_id": Kind::Bytes | Kind::Null,
-        "interface_id": Kind::Bytes | Kind::Null,
-        "log_status": Kind::Bytes | Kind::Null,
-        "packets": Kind::Integer | Kind::Null,
-        "pkt_dstaddr": Kind::Bytes | Kind::Null,
-        "pkt_srcaddr": Kind::Bytes | Kind::Null,
-        "protocol": Kind::Integer | Kind::Null,
-        "region": Kind::Bytes | Kind::Null,
-        "srcaddr": Kind::Bytes | Kind::Null,
-        "srcport": Kind::Integer | Kind::Null,
-        "start": Kind::Integer | Kind::Null,
-        "sublocation_id": Kind::Bytes | Kind::Null,
-        "sublocation_type": Kind::Bytes | Kind::Null,
-        "subnet_id": Kind::Bytes | Kind::Null,
-        "tcp_flags": Kind::Integer | Kind::Null,
-        "type": Kind::Bytes | Kind::Null,
-        "version": Kind::Integer | Kind::Null,
-        "vpc_id": Kind::Bytes | Kind::Null,
+        "account_id": Kind::integer() | Kind::null(),
+        "action": Kind::bytes() | Kind::null(),
+        "az_id": Kind::bytes() | Kind::null(),
+        "bytes": Kind::integer() | Kind::null(),
+        "dstaddr": Kind::bytes() | Kind::null(),
+        "dstport": Kind::integer() | Kind::null(),
+        "end": Kind::integer() | Kind::null(),
+        "instance_id": Kind::bytes() | Kind::null(),
+        "interface_id": Kind::bytes() | Kind::null(),
+        "log_status": Kind::bytes() | Kind::null(),
+        "packets": Kind::integer() | Kind::null(),
+        "pkt_dstaddr": Kind::bytes() | Kind::null(),
+        "pkt_srcaddr": Kind::bytes() | Kind::null(),
+        "protocol": Kind::integer() | Kind::null(),
+        "region": Kind::bytes() | Kind::null(),
+        "srcaddr": Kind::bytes() | Kind::null(),
+        "srcport": Kind::integer() | Kind::null(),
+        "start": Kind::integer() | Kind::null(),
+        "sublocation_id": Kind::bytes() | Kind::null(),
+        "sublocation_type": Kind::bytes() | Kind::null(),
+        "subnet_id": Kind::bytes() | Kind::null(),
+        "tcp_flags": Kind::integer() | Kind::null(),
+        "type": Kind::bytes() | Kind::null(),
+        "version": Kind::integer() | Kind::null(),
+        "vpc_id": Kind::bytes() | Kind::null(),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
 type ParseResult<T> = std::result::Result<T, String>;
@@ -295,7 +296,7 @@ mod tests {
                  "start": 1418530010,
                  "version": 2
              })),
-             tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+             tdef: TypeDef::object(inner_kind()).fallible(),
          }
 
         fields {
@@ -324,7 +325,7 @@ mod tests {
                  "version": 3,
                  "vpc_id": "vpc-abcdefab012345678"
              })),
-             tdef: TypeDef::new().fallible().object::<&str, Kind>(inner_type_def()),
+             tdef: TypeDef::object(inner_kind()).fallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_common_log.rs b/lib/vrl/stdlib/src/parse_common_log.rs
index 2f5d567199de9..7ddd1856c3c0b 100644
--- a/lib/vrl/stdlib/src/parse_common_log.rs
+++ b/lib/vrl/stdlib/src/parse_common_log.rs
@@ -96,23 +96,26 @@ impl Expression for ParseCommonLogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object(type_def())
+        TypeDef::object(inner_kind()).fallible()
     }
 }
 
-fn type_def() -> BTreeMap<&'static str, TypeDef> {
+fn inner_kind() -> BTreeMap<Field, Kind> {
     map! {
-        "host": Kind::Bytes | Kind::Null,
-        "identity": Kind::Bytes | Kind::Null,
-        "user": Kind::Bytes | Kind::Null,
-        "timestamp": Kind::Timestamp | Kind::Null,
-        "message": Kind::Bytes | Kind::Null,
-        "method": Kind::Bytes | Kind::Null,
-        "path": Kind::Bytes | Kind::Null,
-        "protocol": Kind::Bytes | Kind::Null,
-        "status": Kind::Integer | Kind::Null,
-        "size": Kind::Integer | Kind::Null,
+        "host": Kind::bytes() | Kind::null(),
+        "identity": Kind::bytes() | Kind::null(),
+        "user": Kind::bytes() | Kind::null(),
+        "timestamp": Kind::timestamp() | Kind::null(),
+        "message": Kind::bytes() | Kind::null(),
+        "method": Kind::bytes() | Kind::null(),
+        "path": Kind::bytes() | Kind::null(),
+        "protocol": Kind::bytes() | Kind::null(),
+        "status": Kind::integer() | Kind::null(),
+        "size": Kind::integer() | Kind::null(),
     }
+    .into_iter()
+    .map(|(key, kind): (&str, _)| (key.into(), kind))
+    .collect()
 }
 
 #[cfg(test)]
@@ -139,19 +142,19 @@ mod tests {
                 "status" => 200,
                 "size" => 2326,
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_valid_empty {
             args: func_args![value: "- - - - - - -"],
             want: Ok(btreemap! {}),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_valid_empty_variant {
             args: func_args![value: r#"- - - [-] "-" - -"#],
             want: Ok(btreemap! {}),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_valid_with_timestamp_format {
@@ -161,19 +164,19 @@ mod tests {
             want: Ok(btreemap! {
                 "timestamp" => Value::Timestamp(DateTime::parse_from_rfc3339("2000-10-10T20:55:36Z").unwrap().into()),
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid {
             args: func_args![value: r#"not a common log line"#],
             want: Err("failed parsing common log line"),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_timestamp {
             args: func_args![value: r#"- - - [1234] - - -"#],
             want: Err("failed parsing timestamp 1234 using format %d/%b/%Y:%T %z: input contains invalid characters"),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_csv.rs b/lib/vrl/stdlib/src/parse_csv.rs
index 9c3c7497ea392..3157e2e8c5f7f 100644
--- a/lib/vrl/stdlib/src/parse_csv.rs
+++ b/lib/vrl/stdlib/src/parse_csv.rs
@@ -78,13 +78,15 @@ impl Expression for ParseCsvFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().array::<Kind>(type_def())
+        TypeDef::array(inner_kind()).fallible()
     }
 }
 
 #[inline]
-fn type_def() -> Vec<Kind> {
-    vec![Kind::Bytes]
+fn inner_kind() -> Collection<Index> {
+    let mut v = Collection::any();
+    v.set_unknown(Kind::bytes());
+    v
 }
 
 #[cfg(test)]
@@ -97,43 +99,43 @@ mod tests {
         valid {
             args: func_args![value: value!("foo,bar,\"foo \"\", bar\"")],
             want: Ok(value!(["foo", "bar", "foo \", bar"])),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
 
         invalid_utf8 {
             args: func_args![value: value!(&b"foo,b\xFFar"[..])],
             want: Ok(value!(vec!["foo".into(), value!(&b"b\xFFar"[..])])),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
 
         custom_delimiter {
             args: func_args![value: value!("foo bar"), delimiter: value!(" ")],
             want: Ok(value!(["foo", "bar"])),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
 
         invalid_delimiter {
             args: func_args![value: value!("foo bar"), delimiter: value!(",,")],
             want: Err("delimiter must be a single character"),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
 
         single_value {
             args: func_args![value: value!("foo")],
             want: Ok(value!(["foo"])),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
 
         empty_string {
             args: func_args![value: value!("")],
             want: Ok(value!([])),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
 
         multiple_lines {
             args: func_args![value: value!("first,line\nsecond,line,with,more,fields")],
             want: Ok(value!(["first", "line"])),
-            tdef: TypeDef::new().fallible().array::<Kind>(type_def()),
+            tdef: TypeDef::array(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_duration.rs b/lib/vrl/stdlib/src/parse_duration.rs
index 1093cca22190b..d38e921c9af5f 100644
--- a/lib/vrl/stdlib/src/parse_duration.rs
+++ b/lib/vrl/stdlib/src/parse_duration.rs
@@ -119,7 +119,7 @@ impl Expression for ParseDurationFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().float()
+        TypeDef::float().fallible()
     }
 }
 
@@ -134,77 +134,77 @@ mod tests {
             args: func_args![value: "30s",
                              unit: "m"],
             want: Ok(value!(0.5)),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         ms_ms {
             args: func_args![value: "100ms",
                              unit: "ms"],
             want: Ok(100.0),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         ms_s {
             args: func_args![value: "1005ms",
                              unit: "s"],
             want: Ok(1.005),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         ns_ms {
             args: func_args![value: "100ns",
                              unit: "ms"],
             want: Ok(0.0001),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         d_s {
             args: func_args![value: "1d",
                              unit: "s"],
             want: Ok(86400.0),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         s_ns {
             args: func_args![value: "1 s",
                              unit: "ns"],
             want: Ok(1000000000.0),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         us_ms {
             args: func_args![value: "1 µs",
                              unit: "ms"],
             want: Ok(0.001),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         error_invalid {
             args: func_args![value: "foo",
                              unit: "ms"],
             want: Err("unable to parse duration: 'foo'"),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         error_ns {
             args: func_args![value: "1",
                              unit: "ns"],
             want: Err("unable to parse duration: '1'"),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         error_unit {
             args: func_args![value: "1w",
                              unit: "ns"],
             want: Err("unknown duration unit: 'w'"),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
 
         error_format {
             args: func_args![value: "1s",
                              unit: "w"],
             want: Err("unknown unit format: 'w'"),
-            tdef: TypeDef::new().fallible().float(),
+            tdef: TypeDef::float().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_glog.rs b/lib/vrl/stdlib/src/parse_glog.rs
index 948e8d3fd3883..66585d819c98d 100644
--- a/lib/vrl/stdlib/src/parse_glog.rs
+++ b/lib/vrl/stdlib/src/parse_glog.rs
@@ -131,19 +131,19 @@ impl Expression for ParseGlogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object::<&str, Kind>(type_def())
+        TypeDef::object(inner_kind()).fallible()
     }
 }
 
-fn type_def() -> BTreeMap<&'static str, Kind> {
-    map! {
-        "level": Kind::Bytes,
-        "timestamp": Kind::Timestamp,
-        "id": Kind::Integer,
-        "file": Kind::Bytes,
-        "line": Kind::Integer,
-        "message": Kind::Bytes,
-    }
+fn inner_kind() -> BTreeMap<Field, Kind> {
+    BTreeMap::from([
+        ("level".into(), Kind::bytes()),
+        ("timestamp".into(), Kind::timestamp()),
+        ("id".into(), Kind::integer()),
+        ("file".into(), Kind::bytes()),
+        ("line".into(), Kind::integer()),
+        ("message".into(), Kind::bytes()),
+    ])
 }
 
 #[cfg(test)]
@@ -166,7 +166,7 @@ mod tests {
                 "line" => 9,
                 "message" => "Hello world!",
             }),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_valid_strip_whitespace {
@@ -179,31 +179,31 @@ mod tests {
                 "line" => 9,
                 "message" => "Hello world!",
             }),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid {
             args: func_args![value: "not a glog line"],
             want: Err("failed parsing glog message"),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_log_level {
             args: func_args![value: "X20210131 14:48:54.411655 15520 main.c++:9] Hello world!"],
             want: Err(r#"unrecognized log level "X""#),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_timestamp {
             args: func_args![value: "I20210000 14:48:54.411655 15520 main.c++:9] Hello world!"],
             want: Err("failed parsing timestamp 20210000 14:48:54.411655: input is out of range"),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_id {
             args: func_args![value: "I20210131 14:48:54.411655 99999999999999999999999999999 main.c++:9] Hello world!"],
             want: Err("failed parsing id"),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_grok.rs b/lib/vrl/stdlib/src/parse_grok.rs
index 01f9d8e0bd024..dde151bec30a1 100644
--- a/lib/vrl/stdlib/src/parse_grok.rs
+++ b/lib/vrl/stdlib/src/parse_grok.rs
@@ -13,7 +13,7 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::InvalidGrokPattern(err) => write!(f, "{}", err),
+            Error::InvalidGrokPattern(err) => err.fmt(f),
         }
     }
 }
@@ -149,9 +149,7 @@ impl Expression for ParseGrokFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object::<(), Kind>(map! {
-            (): Kind::all(),
-        })
+        TypeDef::object(Collection::any()).fallible()
     }
 }
 
@@ -168,27 +166,21 @@ mod test {
             args: func_args![ value: "foo",
                               pattern: "%{NOG}"],
             want: Err("The given pattern definition name \"NOG\" could not be found in the definition map"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         error {
             args: func_args![ value: "an ungrokkable message",
                               pattern: "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}"],
             want: Err("unable to parse input with grok pattern"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         error2 {
             args: func_args![ value: "2020-10-02T23:22:12.223222Z an ungrokkable message",
                               pattern: "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}"],
             want: Err("unable to parse input with grok pattern"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         parsed {
@@ -199,9 +191,7 @@ mod test {
                 "level" => "info",
                 "message" => "Hello world",
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         parsed2 {
@@ -211,9 +201,7 @@ mod test {
                 "timestamp" => "2020-10-02T23:22:12.223222Z",
                 "level" => "",
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         remove_empty {
@@ -224,9 +212,7 @@ mod test {
             want: Ok(Value::from(
                 btreemap! { "timestamp" => "2020-10-02T23:22:12.223222Z" },
             )),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_groks.rs b/lib/vrl/stdlib/src/parse_groks.rs
index 40ef21fd475a6..e92322f50a15e 100644
--- a/lib/vrl/stdlib/src/parse_groks.rs
+++ b/lib/vrl/stdlib/src/parse_groks.rs
@@ -17,7 +17,7 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::InvalidGrokPattern(err) => write!(f, "{}", err),
+            Error::InvalidGrokPattern(err) => err.fmt(f),
         }
     }
 }
@@ -263,15 +263,13 @@ impl Expression for ParseGrokFn {
         let remove_empty = self.remove_empty.resolve(ctx)?.try_boolean()?;
 
         let v = parse_grok::parse_grok(bytes.as_ref(), &self.grok_rules, remove_empty)
-            .map_err(|e| format!("unable to parse grok: {}", e))?;
+            .map_err(|err| format!("unable to parse grok: {}", err))?;
 
         Ok(v)
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object::<(), Kind>(map! {
-            (): Kind::all(),
-        })
+        TypeDef::object(Collection::any()).fallible()
     }
 }
 
@@ -288,27 +286,21 @@ mod test {
             args: func_args![ value: "foo",
                               patterns: vec!["%{NOG}"]],
             want: Err("failed to parse grok expression '\\A%{NOG}\\z': The given pattern definition name \"NOG\" could not be found in the definition map"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         error {
             args: func_args![ value: "an ungrokkable message",
                               patterns: vec!["%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}"]],
             want: Err("unable to parse grok: value does not match any rule"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         error2 {
             args: func_args![ value: "2020-10-02T23:22:12.223222Z an ungrokkable message",
                               patterns: vec!["%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}"]],
             want: Err("unable to parse grok: value does not match any rule"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         parsed {
@@ -319,9 +311,7 @@ mod test {
                 "level" => "info",
                 "message" => "Hello world",
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         parsed2 {
@@ -331,9 +321,7 @@ mod test {
                 "timestamp" => "2020-10-02T23:22:12.223222Z",
                 "level" => "",
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         remove_empty {
@@ -344,9 +332,7 @@ mod test {
             want: Ok(Value::from(
                 btreemap! { "timestamp" => "2020-10-02T23:22:12.223222Z" },
             )),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         multiple_patterns_and_aliases_first_pattern_matches {
@@ -370,9 +356,7 @@ mod test {
                 "status" => "200",
                 "message" => "hello world"
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         multiple_patterns_and_aliases_second_pattern_matches {
@@ -395,9 +379,7 @@ mod test {
                 "level" => "info",
                 "message" => "hello world"
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         datadog_nginx {
@@ -444,9 +426,7 @@ mod test {
                     }
                 }
             })),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_int.rs b/lib/vrl/stdlib/src/parse_int.rs
index 4b68828d9c4a2..a0231cd3d20dc 100644
--- a/lib/vrl/stdlib/src/parse_int.rs
+++ b/lib/vrl/stdlib/src/parse_int.rs
@@ -101,7 +101,7 @@ impl Expression for ParseIntFn {
     }
 
     fn type_def(&self, _state: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().integer()
+        TypeDef::integer().fallible()
     }
 }
 
@@ -115,31 +115,31 @@ mod tests {
         decimal {
              args: func_args![value: "-42"],
              want: Ok(-42),
-             tdef: TypeDef::new().fallible().integer(),
+             tdef: TypeDef::integer().fallible(),
         }
 
         binary {
              args: func_args![value: "0b1001"],
              want: Ok(9),
-             tdef: TypeDef::new().fallible().integer(),
+             tdef: TypeDef::integer().fallible(),
         }
 
         octal {
              args: func_args![value: "042"],
              want: Ok(34),
-             tdef: TypeDef::new().fallible().integer(),
+             tdef: TypeDef::integer().fallible(),
         }
 
         hexadecimal {
              args: func_args![value: "0x2a"],
              want: Ok(42),
-             tdef: TypeDef::new().fallible().integer(),
+             tdef: TypeDef::integer().fallible(),
         }
 
         explicit_hexadecimal {
              args: func_args![value: "2a", base: 16],
              want: Ok(42),
-             tdef: TypeDef::new().fallible().integer(),
+             tdef: TypeDef::integer().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_json.rs b/lib/vrl/stdlib/src/parse_json.rs
index 1fae1139701bc..c949a83640713 100644
--- a/lib/vrl/stdlib/src/parse_json.rs
+++ b/lib/vrl/stdlib/src/parse_json.rs
@@ -116,25 +116,24 @@ impl Expression for ParseJsonFn {
 }
 
 fn inner_kind() -> Kind {
-    Kind::Null
-        | Kind::Bytes
-        | Kind::Integer
-        | Kind::Float
-        | Kind::Boolean
-        | Kind::Array
-        | Kind::Object
+    Kind::null()
+        | Kind::bytes()
+        | Kind::integer()
+        | Kind::float()
+        | Kind::boolean()
+        | Kind::array(Collection::any())
+        | Kind::object(Collection::any())
 }
 
 fn type_def() -> TypeDef {
-    TypeDef::new()
+    TypeDef::bytes()
         .fallible()
-        .bytes()
         .add_boolean()
         .add_integer()
         .add_float()
         .add_null()
-        .add_array_mapped::<(), Kind>(map! { (): inner_kind() })
-        .add_object::<(), Kind>(map! { (): inner_kind() })
+        .add_array(Collection::from_unknown(inner_kind()))
+        .add_object(Collection::from_unknown(inner_kind()))
 }
 
 #[cfg(test)]
@@ -159,15 +158,13 @@ mod tests {
         invalid_json_errors {
             args: func_args![ value: r#"{"field": "value"# ],
             want: Err("unable to parse json: EOF while parsing a string at line 1 column 16"),
-            tdef: TypeDef::new()
-                .fallible()
-                .bytes()
+            tdef: TypeDef::bytes().fallible()
                 .add_boolean()
                 .add_integer()
                 .add_float()
                 .add_null()
-                .add_array_mapped::<(), Kind>(map! { (): inner_kind() })
-                .add_object::<(), Kind>(map! { (): inner_kind() }),
+                .add_array(Collection::from_unknown(inner_kind()))
+                .add_object(Collection::from_unknown(inner_kind())),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_key_value.rs b/lib/vrl/stdlib/src/parse_key_value.rs
index d61dca61e8ace..3091e9ee37670 100644
--- a/lib/vrl/stdlib/src/parse_key_value.rs
+++ b/lib/vrl/stdlib/src/parse_key_value.rs
@@ -257,9 +257,7 @@ impl Expression for ParseKeyValueFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object::<(), Kind>(map! {
-            (): Kind::all()
-        })
+        TypeDef::object(Collection::any()).fallible()
     }
 }
 
@@ -720,9 +718,7 @@ mod test {
                              bytes: "13",
                              tls_version: "tls1.1",
                              protocol: "http"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         logfmt {
@@ -734,9 +730,7 @@ mod test {
                              tag: "stopping_fetchers",
                              id: "ConsumerFetcherManager-1382721708341",
                              module: "kafka.consumer.ConsumerFetcherManager"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         // From https://github.com/vectordotdev/vector/issues/5347
@@ -754,9 +748,7 @@ mod test {
                              PolicyID: "3",
                              Action: "PERMIT",
                              Content: "Session Backout"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         strict {
@@ -767,9 +759,7 @@ mod test {
             want: Ok(value!({foo: "",
                              bar: "",
                              tar: "data"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         spaces {
@@ -779,9 +769,7 @@ mod test {
             ],
             want: Ok(value!({"zork one": r#"zoog\"zink\"zork"#,
                              nonk: "nink"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         delimited {
@@ -792,9 +780,7 @@ mod test {
             ],
             want: Ok(value!({"zork one": r#"zoog\"zink\"zork"#,
                              nonk: "nink"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         delimited_with_spaces {
@@ -805,9 +791,7 @@ mod test {
             ],
             want: Ok(value!({"zork one": r#"zoog\"zink\"zork"#,
                              nonk: "nink"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         multiple_chars {
@@ -818,9 +802,7 @@ mod test {
             ],
             want: Ok(value!({"zork one": r#"zoog\"zink\"zork"#,
                              nonk: "nink"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         error {
@@ -831,9 +813,7 @@ mod test {
                 accept_standalone_key: false,
             ],
             want: Err("0: at line 1, in Tag:\nI am not a valid line.\n                      ^\n\n1: at line 1, in ManyMN:\nI am not a valid line.\n                      ^\n\n"),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         // The following case demonstrates a scenario that could potentially be considered an
@@ -848,9 +828,7 @@ mod test {
             ],
             want: Ok(value!({zork: r#"zoog"#,
                              nonk: "nink norgle: noog"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         // If the value field is delimited and we miss the separator,
@@ -863,9 +841,7 @@ mod test {
             ],
             want: Ok(value!({zork: "zoog",
                              nonk: r#""nink" norgle: noog"#})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         multi_line_with_quotes {
@@ -876,9 +852,7 @@ mod test {
             ],
             want: Ok(value!({"To": "tom",
                              "test": "\"tom\" test"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
 
         multi_line_with_quotes_spaces {
@@ -889,9 +863,7 @@ mod test {
             ],
             want: Ok(value!({"To": "tom",
                              "test": "tom test"})),
-            tdef: TypeDef::new().fallible().object::<(), Kind>(map! {
-                (): Kind::all()
-            }),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_klog.rs b/lib/vrl/stdlib/src/parse_klog.rs
index 54ea8854f59fe..30d71408c4bbf 100644
--- a/lib/vrl/stdlib/src/parse_klog.rs
+++ b/lib/vrl/stdlib/src/parse_klog.rs
@@ -132,7 +132,7 @@ impl Expression for ParseKlogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object::<&str, Kind>(type_def())
+        TypeDef::object(inner_kind()).fallible()
     }
 }
 
@@ -146,15 +146,15 @@ fn resolve_year(month: Option<&str>) -> i32 {
     }
 }
 
-fn type_def() -> BTreeMap<&'static str, Kind> {
-    map! {
-        "level": Kind::Bytes,
-        "timestamp": Kind::Timestamp,
-        "id": Kind::Integer,
-        "file": Kind::Bytes,
-        "line": Kind::Integer,
-        "message": Kind::Bytes,
-    }
+fn inner_kind() -> BTreeMap<Field, Kind> {
+    BTreeMap::from([
+        ("level".into(), Kind::bytes()),
+        ("timestamp".into(), Kind::timestamp()),
+        ("id".into(), Kind::integer()),
+        ("file".into(), Kind::bytes()),
+        ("line".into(), Kind::integer()),
+        ("message".into(), Kind::bytes()),
+    ])
 }
 
 #[cfg(test)]
@@ -177,7 +177,7 @@ mod tests {
                 "line" => 70,
                 "message" => "hello from klog",
             }),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_valid_strip_whitespace {
@@ -190,31 +190,31 @@ mod tests {
                 "line" => 70,
                 "message" => "hello from klog",
             }),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid {
             args: func_args![value: "not a klog line"],
             want: Err("failed parsing klog message"),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_log_level {
             args: func_args![value: "X0505 17:59:40.692994   28133 klog.go:70] hello from klog"],
             want: Err(r#"unrecognized log level "X""#),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_timestamp {
             args: func_args![value: "I0000 17:59:40.692994   28133 klog.go:70] hello from klog"],
             want: Err("failed parsing timestamp 0000 17:59:40.692994: input is out of range"),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         log_line_invalid_id {
             args: func_args![value: "I0505 17:59:40.692994   99999999999999999999999999999 klog.go:70] hello from klog"],
             want: Err("failed parsing id"),
-            tdef: TypeDef::new().fallible().object::<&str, Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_nginx_log.rs b/lib/vrl/stdlib/src/parse_nginx_log.rs
index 6bf4213468c0a..027953ce575fc 100644
--- a/lib/vrl/stdlib/src/parse_nginx_log.rs
+++ b/lib/vrl/stdlib/src/parse_nginx_log.rs
@@ -130,47 +130,46 @@ impl Expression for ParseNginxLogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible()
-            .object(match self.format.as_ref() {
-                b"combined" => type_def_combined(),
-                b"error" => type_def_error(),
-                _ => unreachable!(),
-            })
+        TypeDef::object(match self.format.as_ref() {
+            b"combined" => kind_combined(),
+            b"error" => kind_error(),
+            _ => unreachable!(),
+        })
+        .fallible()
     }
 }
 
-fn type_def_combined() -> BTreeMap<&'static str, TypeDef> {
-    map! {
-        "client": Kind::Bytes,
-        "user": Kind::Bytes | Kind::Null,
-        "timestamp": Kind::Timestamp,
-        "request": Kind::Bytes,
-        "method": Kind::Bytes,
-        "path": Kind::Bytes,
-        "protocol": Kind::Bytes,
-        "status": Kind::Integer,
-        "size": Kind::Integer,
-        "referer": Kind::Bytes | Kind::Null,
-        "agent": Kind::Bytes | Kind::Null,
-        "compression": Kind::Bytes | Kind::Null,
-    }
+fn kind_combined() -> BTreeMap<Field, Kind> {
+    BTreeMap::from([
+        ("client".into(), Kind::bytes()),
+        ("user".into(), Kind::bytes().or_null()),
+        ("timestamp".into(), Kind::timestamp()),
+        ("request".into(), Kind::bytes()),
+        ("method".into(), Kind::bytes()),
+        ("path".into(), Kind::bytes()),
+        ("protocol".into(), Kind::bytes()),
+        ("status".into(), Kind::integer()),
+        ("size".into(), Kind::integer()),
+        ("referer".into(), Kind::bytes().or_null()),
+        ("agent".into(), Kind::bytes().or_null()),
+        ("compression".into(), Kind::bytes().or_null()),
+    ])
 }
 
-fn type_def_error() -> BTreeMap<&'static str, TypeDef> {
-    map! {
-        "timestamp": Kind::Timestamp,
-        "severity": Kind::Bytes,
-        "pid": Kind::Integer,
-        "tid": Kind::Integer,
-        "cid": Kind::Integer,
-        "message": Kind::Bytes,
-        "client": Kind::Bytes | Kind::Null,
-        "server": Kind::Bytes | Kind::Null,
-        "request": Kind::Bytes | Kind::Null,
-        "host": Kind::Bytes | Kind::Null,
-        "port": Kind::Bytes | Kind::Null,
-    }
+fn kind_error() -> BTreeMap<Field, Kind> {
+    BTreeMap::from([
+        ("timestamp".into(), Kind::timestamp()),
+        ("severity".into(), Kind::bytes()),
+        ("pid".into(), Kind::integer()),
+        ("tid".into(), Kind::integer()),
+        ("cid".into(), Kind::integer()),
+        ("message".into(), Kind::bytes()),
+        ("client".into(), Kind::bytes().or_null()),
+        ("server".into(), Kind::bytes().or_null()),
+        ("request".into(), Kind::bytes().or_null()),
+        ("host".into(), Kind::bytes().or_null()),
+        ("port".into(), Kind::bytes().or_null()),
+    ])
 }
 
 #[cfg(test)]
@@ -199,7 +198,7 @@ mod tests {
                 "size" => 612,
                 "agent" => "curl/7.75.0",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_combined()),
+            tdef: TypeDef::object(kind_combined()).fallible(),
         }
 
         combined_line_valid_no_compression {
@@ -219,7 +218,7 @@ mod tests {
                 "referer" => "https://my-url.com/my-path",
                 "agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_combined()),
+            tdef: TypeDef::object(kind_combined()).fallible(),
         }
 
         combined_line_valid_all_fields {
@@ -241,7 +240,7 @@ mod tests {
                 "agent" => "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36",
                 "compression" => "2.75",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_combined()),
+            tdef: TypeDef::object(kind_combined()).fallible(),
         }
 
         error_line_valid {
@@ -261,7 +260,7 @@ mod tests {
                 "request" => "POST /not-found HTTP/1.1",
                 "host" => "localhost:8081",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
         }
 
         error_line_with_referrer {
@@ -282,7 +281,7 @@ mod tests {
                 "host" => "65.21.190.83:31256",
                 "referer" => "http://65.21.190.83:31256/",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
         }
 
         error_line_starting {
@@ -297,7 +296,7 @@ mod tests {
                 "tid" => 133309,
                 "message" => "signal process started",
             }),
-            tdef: TypeDef::new().fallible().object(type_def_error()),
+            tdef: TypeDef::object(kind_error()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_query_string.rs b/lib/vrl/stdlib/src/parse_query_string.rs
index b0a484b9fc870..028cddd56fc6e 100644
--- a/lib/vrl/stdlib/src/parse_query_string.rs
+++ b/lib/vrl/stdlib/src/parse_query_string.rs
@@ -79,14 +79,12 @@ impl Expression for ParseQueryStringFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().object::<(), Kind>(type_def())
+        TypeDef::object(inner_kind())
     }
 }
 
-fn type_def() -> BTreeMap<(), Kind> {
-    map! {
-        (): Kind::Bytes | Kind::Array,
-    }
+fn inner_kind() -> Collection<Field> {
+    Collection::from_unknown(Kind::bytes().or_array(Collection::any()))
 }
 
 #[cfg(test)]
@@ -104,7 +102,7 @@ mod tests {
                 xyz: "",
                 abc: "",
             })),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
 
         multiple_values {
@@ -112,7 +110,7 @@ mod tests {
             want: Ok(value!({
                 foo: ["bar", "xyz"],
             })),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
 
         ruby_on_rails_multiple_values {
@@ -120,7 +118,7 @@ mod tests {
             want: Ok(value!({
                 "foo[]": ["bar", "xyz"],
             })),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
 
         empty_key {
@@ -128,7 +126,7 @@ mod tests {
             want: Ok(value!({
                 "": ["", ""],
             })),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
 
         single_key {
@@ -136,13 +134,13 @@ mod tests {
             want: Ok(value!({
                 foo: "",
             })),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
 
         empty {
             args: func_args![value: value!("")],
             want: Ok(value!({})),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
 
         starts_with_question_mark {
@@ -150,7 +148,7 @@ mod tests {
             want: Ok(value!({
                 foo: "bar",
             })),
-            tdef: TypeDef::new().infallible().object::<(), Kind>(type_def()),
+            tdef: TypeDef::object(inner_kind()),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_regex.rs b/lib/vrl/stdlib/src/parse_regex.rs
index 5003ec8c9c26b..554d1a7223a34 100644
--- a/lib/vrl/stdlib/src/parse_regex.rs
+++ b/lib/vrl/stdlib/src/parse_regex.rs
@@ -151,9 +151,7 @@ impl Expression for ParseRegexFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible()
-            .object(util::regex_type_def(&self.pattern))
+        TypeDef::object(util::regex_kind(&self.pattern)).fallible()
     }
 }
 
@@ -161,6 +159,7 @@ impl Expression for ParseRegexFn {
 #[allow(clippy::trivial_regex)]
 mod tests {
     use super::*;
+    use vector_common::btreemap;
 
     test_function![
         find => ParseRegex;
@@ -190,27 +189,25 @@ mod tests {
                              "7": "201",
                              "8": "20574",
             })),
-            tdef: TypeDef::new()
-                .fallible()
-                .object::<&str, Kind>(map! {
-                    "bytes_in": Kind::Bytes,
-                    "host": Kind::Bytes,
-                    "user": Kind::Bytes,
-                    "timestamp": Kind::Bytes,
-                    "method": Kind::Bytes,
-                    "path": Kind::Bytes,
-                    "status": Kind::Bytes,
-                    "bytes_out": Kind::Bytes,
-                    "0": Kind::Bytes | Kind::Null,
-                    "1": Kind::Bytes | Kind::Null,
-                    "2": Kind::Bytes | Kind::Null,
-                    "3": Kind::Bytes | Kind::Null,
-                    "4": Kind::Bytes | Kind::Null,
-                    "5": Kind::Bytes | Kind::Null,
-                    "6": Kind::Bytes | Kind::Null,
-                    "7": Kind::Bytes | Kind::Null,
-                    "8": Kind::Bytes | Kind::Null,
-                }),
+            tdef: TypeDef::object(btreemap! {
+                    Field::from("bytes_in") => Kind::bytes(),
+                    Field::from("host") => Kind::bytes(),
+                    Field::from("user") => Kind::bytes(),
+                    Field::from("timestamp") => Kind::bytes(),
+                    Field::from("method") => Kind::bytes(),
+                    Field::from("path") => Kind::bytes(),
+                    Field::from("status") => Kind::bytes(),
+                    Field::from("bytes_out") => Kind::bytes(),
+                    Field::from("0") => Kind::bytes() | Kind::null(),
+                    Field::from("1") => Kind::bytes() | Kind::null(),
+                    Field::from("2") => Kind::bytes() | Kind::null(),
+                    Field::from("3") => Kind::bytes() | Kind::null(),
+                    Field::from("4") => Kind::bytes() | Kind::null(),
+                    Field::from("5") => Kind::bytes() | Kind::null(),
+                    Field::from("6") => Kind::bytes() | Kind::null(),
+                    Field::from("7") => Kind::bytes() | Kind::null(),
+                    Field::from("8") => Kind::bytes() | Kind::null(),
+                }).fallible(),
         }
 
         single_match {
@@ -219,13 +216,11 @@ mod tests {
                 pattern: Regex::new(r#"(?P<number>.*?) group"#).unwrap()
             ],
             want: Ok(value!({"number": "first"})),
-            tdef: TypeDef::new()
-                .fallible()
-                .object::<&str, Kind>(map! {
-                        "number": Kind::Bytes,
-                        "0": Kind::Bytes | Kind::Null,
-                        "1": Kind::Bytes | Kind::Null,
-                }),
+            tdef: TypeDef::object(btreemap! {
+                        Field::from("number") => Kind::bytes(),
+                        Field::from("0") => Kind::bytes() | Kind::null(),
+                        Field::from("1") => Kind::bytes() | Kind::null(),
+                }).fallible(),
         }
 
         no_match {
@@ -235,27 +230,25 @@ mod tests {
                             .unwrap()
             ],
             want: Err("could not find any pattern matches"),
-            tdef: TypeDef::new()
-                .fallible()
-                .object::<&str, Kind>(map! {
-                    "host": Kind::Bytes,
-                    "user": Kind::Bytes,
-                    "bytes_in": Kind::Bytes,
-                    "timestamp": Kind::Bytes,
-                    "method": Kind::Bytes,
-                    "path": Kind::Bytes,
-                    "status": Kind::Bytes,
-                    "bytes_out": Kind::Bytes,
-                    "0": Kind::Bytes | Kind::Null,
-                    "1": Kind::Bytes | Kind::Null,
-                    "2": Kind::Bytes | Kind::Null,
-                    "3": Kind::Bytes | Kind::Null,
-                    "4": Kind::Bytes | Kind::Null,
-                    "5": Kind::Bytes | Kind::Null,
-                    "6": Kind::Bytes | Kind::Null,
-                    "7": Kind::Bytes | Kind::Null,
-                    "8": Kind::Bytes | Kind::Null,
-                }),
+            tdef: TypeDef::object(btreemap! {
+                    Field::from("host") => Kind::bytes(),
+                    Field::from("user") => Kind::bytes(),
+                    Field::from("bytes_in") => Kind::bytes(),
+                    Field::from("timestamp") => Kind::bytes(),
+                    Field::from("method") => Kind::bytes(),
+                    Field::from("path") => Kind::bytes(),
+                    Field::from("status") => Kind::bytes(),
+                    Field::from("bytes_out") => Kind::bytes(),
+                    Field::from("0") => Kind::bytes() | Kind::null(),
+                    Field::from("1") => Kind::bytes() | Kind::null(),
+                    Field::from("2") => Kind::bytes() | Kind::null(),
+                    Field::from("3") => Kind::bytes() | Kind::null(),
+                    Field::from("4") => Kind::bytes() | Kind::null(),
+                    Field::from("5") => Kind::bytes() | Kind::null(),
+                    Field::from("6") => Kind::bytes() | Kind::null(),
+                    Field::from("7") => Kind::bytes() | Kind::null(),
+                    Field::from("8") => Kind::bytes() | Kind::null(),
+                }).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_regex_all.rs b/lib/vrl/stdlib/src/parse_regex_all.rs
index 1710e96cac214..f6b81b604a7e7 100644
--- a/lib/vrl/stdlib/src/parse_regex_all.rs
+++ b/lib/vrl/stdlib/src/parse_regex_all.rs
@@ -156,13 +156,10 @@ impl Expression for ParseRegexAllFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        let inner_type_def = TypeDef::new()
-            .object(util::regex_type_def(&self.pattern))
-            .add_null();
-
-        TypeDef::new()
-            .fallible()
-            .array_mapped::<(), TypeDef>(map![(): inner_type_def])
+        TypeDef::array(Collection::from_unknown(
+            Kind::object(util::regex_kind(&self.pattern)).or_null(),
+        ))
+        .fallible()
     }
 }
 
@@ -170,6 +167,7 @@ impl Expression for ParseRegexAllFn {
 #[allow(clippy::trivial_regex)]
 mod tests {
     use super::*;
+    use vector_common::btreemap;
 
     test_function![
         parse_regex_all => ParseRegexAll;
@@ -183,18 +181,13 @@ mod tests {
                               "veg": "carrots"},
                              {"fruit": "peaches",
                               "veg": "peas"}])),
-            tdef: TypeDef::new()
-                .fallible()
-                .array_mapped::<(), TypeDef>(map![(): TypeDef::new()
-                                                  .object::<&str, Kind>(map! {
-                                                      "fruit": Kind::Bytes,
-                                                      "veg": Kind::Bytes,
-                                                      "0": Kind::Bytes | Kind::Null,
-                                                      "1": Kind::Bytes | Kind::Null,
-                                                      "2": Kind::Bytes | Kind::Null,
-                                                  })
-                                                  .add_null()
-            ]),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::null().or_object(btreemap! {
+                    Field::from("fruit") => Kind::bytes(),
+                    Field::from("veg") => Kind::bytes(),
+                    Field::from("0") => Kind::bytes() | Kind::null(),
+                    Field::from("1") => Kind::bytes() | Kind::null(),
+                    Field::from("2") => Kind::bytes() | Kind::null(),
+                }))).fallible(),
         }
 
         numeric_groups {
@@ -213,18 +206,13 @@ mod tests {
                               "0": "peaches and peas",
                               "1": "peaches",
                               "2": "peas"}])),
-            tdef: TypeDef::new()
-                .fallible()
-                .array_mapped::<(), TypeDef>(map![(): TypeDef::new()
-                                                  .object::<&str, Kind>(map! {
-                                                      "fruit": Kind::Bytes,
-                                                      "veg": Kind::Bytes,
-                                                      "0": Kind::Bytes | Kind::Null,
-                                                      "1": Kind::Bytes | Kind::Null,
-                                                      "2": Kind::Bytes | Kind::Null,
-                                                  })
-                                                  .add_null()
-            ]),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::null().or_object(btreemap! {
+                    Field::from("fruit") => Kind::bytes(),
+                    Field::from("veg") => Kind::bytes(),
+                    Field::from("0") => Kind::bytes() | Kind::null(),
+                    Field::from("1") => Kind::bytes() | Kind::null(),
+                    Field::from("2") => Kind::bytes() | Kind::null(),
+                }))).fallible(),
         }
 
         no_matches {
@@ -233,18 +221,13 @@ mod tests {
                 pattern: Regex::new(r#"(?P<fruit>[\w\.]+) and (?P<veg>[\w]+)"#).unwrap()
             ],
             want: Ok(value!([])),
-            tdef: TypeDef::new()
-                .fallible()
-                .array_mapped::<(), TypeDef>(map![(): TypeDef::new()
-                                                  .object::<&str, Kind>(map! {
-                                                      "fruit": Kind::Bytes,
-                                                      "veg": Kind::Bytes,
-                                                      "0": Kind::Bytes | Kind::Null,
-                                                      "1": Kind::Bytes | Kind::Null,
-                                                      "2": Kind::Bytes | Kind::Null,
-                                                  })
-                                                  .add_null()
-                ]),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::null().or_object(btreemap! {
+                    Field::from("fruit") => Kind::bytes(),
+                    Field::from("veg") => Kind::bytes(),
+                    Field::from("0") => Kind::bytes() | Kind::null(),
+                    Field::from("1") => Kind::bytes() | Kind::null(),
+                    Field::from("2") => Kind::bytes() | Kind::null(),
+                }))).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_ruby_hash.rs b/lib/vrl/stdlib/src/parse_ruby_hash.rs
index d677c2601de83..3ae5922dd10c6 100644
--- a/lib/vrl/stdlib/src/parse_ruby_hash.rs
+++ b/lib/vrl/stdlib/src/parse_ruby_hash.rs
@@ -70,18 +70,17 @@ impl Expression for ParseRubyHashFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        type_def()
+        TypeDef::object(Collection::from_unknown(inner_kinds())).fallible()
     }
 }
 
-fn kinds() -> Kind {
-    Kind::Null | Kind::Bytes | Kind::Float | Kind::Boolean | Kind::Array | Kind::Object
-}
-
-fn type_def() -> TypeDef {
-    TypeDef::new()
-        .fallible()
-        .add_object::<(), Kind>(map! { (): kinds() })
+fn inner_kinds() -> Kind {
+    Kind::null()
+        | Kind::bytes()
+        | Kind::float()
+        | Kind::boolean()
+        | Kind::array(Collection::any())
+        | Kind::object(Collection::any())
 }
 
 trait HashParseError<T>: ParseError<T> + ContextError<T> + FromExternalError<T, ParseIntError> {}
@@ -400,7 +399,7 @@ mod tests {
                     testBool: true
                 }
             })),
-            tdef: type_def(),
+            tdef: TypeDef::object(Collection::from_unknown(inner_kinds())).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_syslog.rs b/lib/vrl/stdlib/src/parse_syslog.rs
index 2f2dbf3bfab0f..9d77d3c91b121 100644
--- a/lib/vrl/stdlib/src/parse_syslog.rs
+++ b/lib/vrl/stdlib/src/parse_syslog.rs
@@ -89,7 +89,7 @@ impl Expression for ParseSyslogFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object(type_def())
+        TypeDef::object(inner_kind()).fallible()
     }
 }
 
@@ -158,18 +158,18 @@ fn message_to_value(message: Message<&str>) -> Value {
     result.into()
 }
 
-fn type_def() -> BTreeMap<&'static str, TypeDef> {
-    map! {
-        "message": Kind::Bytes,
-        "hostname": Kind::Bytes | Kind::Null,
-        "severity": Kind::Bytes | Kind::Null,
-        "facility": Kind::Bytes | Kind::Null,
-        "appname": Kind::Bytes | Kind::Null,
-        "msgid": Kind::Bytes | Kind::Null,
-        "timestamp": Kind::Timestamp | Kind::Null,
-        "procid": Kind::Bytes | Kind::Integer | Kind::Null,
-        "version": Kind::Integer | Kind::Null
-    }
+fn inner_kind() -> BTreeMap<Field, Kind> {
+    BTreeMap::from([
+        ("message".into(), Kind::bytes()),
+        ("hostname".into(), Kind::bytes().or_null()),
+        ("severity".into(), Kind::bytes().or_null()),
+        ("facility".into(), Kind::bytes().or_null()),
+        ("appname".into(), Kind::bytes().or_null()),
+        ("msgid".into(), Kind::bytes().or_null()),
+        ("timestamp".into(), Kind::timestamp().or_null()),
+        ("procid".into(), Kind::bytes().or_integer().or_null()),
+        ("version".into(), Kind::integer().or_null()),
+    ])
 }
 
 #[cfg(test)]
@@ -198,13 +198,13 @@ mod tests {
                 "message" => "Try to override the THX port, maybe it will reboot the neural interface!",
                 "version" => 1,
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         invalid {
             args: func_args![value: "not much of a syslog message"],
             want: Err("unable to parse input as valid syslog message".to_string()),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         haproxy {
@@ -217,7 +217,7 @@ mod tests {
                     "appname" => "haproxy",
                     "procid" => 73411,
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         missing_pri {
@@ -228,7 +228,7 @@ mod tests {
                 "appname" => "haproxy",
                 "procid" => 73411,
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         empty_sd_element {
@@ -244,7 +244,7 @@ mod tests {
                 "timestamp" => chrono::Utc.ymd(2019, 2, 13).and_hms_milli(19, 48, 34, 0),
                 "version" => 1,
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         non_empty_sd_element {
@@ -261,7 +261,7 @@ mod tests {
                 "version" => 1,
                 "non_empty.x" => "1",
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         non_structured_data_in_message {
@@ -274,7 +274,7 @@ mod tests {
                 "timestamp" => chrono::Utc.ymd(chrono::Utc::now().year(), 6, 8).and_hms_milli(11, 54, 8, 0),
                 "message" => "[Tue Jun 08 11:54:08.929301 2021] [php7:emerg] [pid 1374899] [client 95.223.77.60:41888] rest of message",
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         escapes_in_structured_data_quote {
@@ -290,7 +290,7 @@ mod tests {
                 "timestamp" => chrono::Utc.ymd(2003, 10, 11).and_hms_milli(22,14,15,3),
                 "version" => 1
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         escapes_in_structured_data_slash {
@@ -306,7 +306,7 @@ mod tests {
                 "timestamp" => chrono::Utc.ymd(2003, 10, 11).and_hms_milli(22,14,15,3),
                 "version" => 1
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         escapes_in_structured_data_bracket {
@@ -322,7 +322,7 @@ mod tests {
                 "timestamp" => chrono::Utc.ymd(2003,10,11).and_hms_milli(22,14,15,3),
                 "version" => 1
             }),
-            tdef: TypeDef::new().fallible().object(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_timestamp.rs b/lib/vrl/stdlib/src/parse_timestamp.rs
index 0c2d2be566e6e..312a578840274 100644
--- a/lib/vrl/stdlib/src/parse_timestamp.rs
+++ b/lib/vrl/stdlib/src/parse_timestamp.rs
@@ -70,9 +70,7 @@ impl Expression for ParseTimestampFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .fallible() // Always fallible because the format needs to be parsed at runtime
-            .timestamp()
+        TypeDef::timestamp().fallible(/* always fallible because the format needs to be parsed at runtime */)
     }
 }
 
@@ -97,7 +95,7 @@ mod tests {
                     .unwrap()
                     .with_timezone(&Utc)
             )),
-            tdef: TypeDef::new().fallible().timestamp(),
+            tdef: TypeDef::timestamp().fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -111,7 +109,7 @@ mod tests {
                     .unwrap()
                     .with_timezone(&Utc)
             )),
-            tdef: TypeDef::new().fallible().timestamp(),
+            tdef: TypeDef::timestamp().fallible(),
             tz: vector_common::TimeZone::default(),
         }
 
@@ -125,7 +123,7 @@ mod tests {
                     .unwrap()
                     .with_timezone(&Utc)
             )),
-            tdef: TypeDef::new().fallible().timestamp(),
+            tdef: TypeDef::timestamp().fallible(),
             tz: vector_common::TimeZone::Named(chrono_tz::Europe::Paris),
         }
     ];
diff --git a/lib/vrl/stdlib/src/parse_tokens.rs b/lib/vrl/stdlib/src/parse_tokens.rs
index 5e3851abfea37..525ba1bd381b8 100644
--- a/lib/vrl/stdlib/src/parse_tokens.rs
+++ b/lib/vrl/stdlib/src/parse_tokens.rs
@@ -62,9 +62,7 @@ impl Expression for ParseTokensFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().array_mapped::<(), Kind>(map! {
-            (): Kind::Bytes
-        })
+        TypeDef::array(Collection::from_unknown(Kind::bytes()))
     }
 }
 
@@ -87,9 +85,7 @@ mod tests {
                             "11881".into(),
 
                     ]),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! {
-                (): Kind::Bytes
-            }),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_url.rs b/lib/vrl/stdlib/src/parse_url.rs
index bedaca4a9dd75..27c5b7189bd62 100644
--- a/lib/vrl/stdlib/src/parse_url.rs
+++ b/lib/vrl/stdlib/src/parse_url.rs
@@ -113,7 +113,7 @@ impl Expression for ParseUrlFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().object(type_def())
+        TypeDef::object(inner_kind()).fallible()
     }
 }
 
@@ -153,19 +153,20 @@ fn url_to_value(url: Url, default_known_ports: bool) -> Value {
         .collect::<Value>()
 }
 
-fn type_def() -> BTreeMap<&'static str, TypeDef> {
-    map! {
-        "scheme": Kind::Bytes,
-        "username": Kind::Bytes,
-        "password": Kind::Bytes,
-        "path": Kind::Bytes | Kind::Null,
-        "host": Kind::Bytes,
-        "port": Kind::Integer | Kind::Null,
-        "fragment": Kind::Bytes | Kind::Null,
-        "query": TypeDef::new().object::<(), Kind>(map! {
-            (): Kind::Bytes,
-        }),
-    }
+fn inner_kind() -> BTreeMap<Field, Kind> {
+    BTreeMap::from([
+        ("scheme".into(), Kind::bytes()),
+        ("username".into(), Kind::bytes()),
+        ("password".into(), Kind::bytes()),
+        ("path".into(), Kind::bytes().or_null()),
+        ("host".into(), Kind::bytes()),
+        ("port".into(), Kind::integer().or_null()),
+        ("fragment".into(), Kind::bytes().or_null()),
+        (
+            "query".into(),
+            Kind::object(Collection::from_unknown(Kind::bytes())),
+        ),
+    ])
 }
 
 #[cfg(test)]
@@ -187,7 +188,7 @@ mod tests {
                 scheme: "https",
                 username: "",
             })),
-            tdef: TypeDef::new().fallible().object::<&'static str, TypeDef>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         default_port_specified {
@@ -202,7 +203,7 @@ mod tests {
                 scheme: "https",
                 username: "",
             })),
-            tdef: TypeDef::new().fallible().object::<&'static str, TypeDef>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
 
         default_port {
@@ -217,7 +218,7 @@ mod tests {
                 scheme: "https",
                 username: "",
             })),
-            tdef: TypeDef::new().fallible().object::<&'static str, TypeDef>(type_def()),
+            tdef: TypeDef::object(inner_kind()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/parse_user_agent.rs b/lib/vrl/stdlib/src/parse_user_agent.rs
index 5dd753cc6de48..9507070751fdf 100644
--- a/lib/vrl/stdlib/src/parse_user_agent.rs
+++ b/lib/vrl/stdlib/src/parse_user_agent.rs
@@ -279,46 +279,61 @@ impl Mode {
 
     fn type_def(self) -> TypeDef {
         match self {
-            Mode::Fast | Mode::Reliable => TypeDef::new()
-                .infallible()
-                .object::<&'static str, TypeDef>(map! {
-                    "browser": TypeDef::new().infallible().object::<&'static str,Kind>(map!{
-                        "family": Kind::Bytes | Kind::Null,
-                        "version": Kind::Bytes | Kind::Null,
-                    }),
-                    "os": TypeDef::new().infallible().object::<&'static str,Kind>(map!{
-                        "family": Kind::Bytes | Kind::Null,
-                        "version": Kind::Bytes | Kind::Null,
-                    }),
-                    "device": TypeDef::new().infallible().object::<&'static str,Kind>(map!{
-                        "category": Kind::Bytes | Kind::Null,
-                    }),
-                }),
-            Mode::Enriched => TypeDef::new()
-                .infallible()
-                .object::<&'static str, TypeDef>(map! {
-                    "browser": TypeDef::new().infallible().object::<&'static str,Kind>(map!{
-                        "family": Kind::Bytes | Kind::Null,
-                        "version": Kind::Bytes | Kind::Null,
-                        "major": Kind::Bytes | Kind::Null,
-                        "minor": Kind::Bytes | Kind::Null,
-                        "patch": Kind::Bytes | Kind::Null,
-                    }),
-                    "os": TypeDef::new().infallible().object::<&'static str,Kind>(map!{
-                        "family": Kind::Bytes | Kind::Null,
-                        "version": Kind::Bytes | Kind::Null,
-                        "major": Kind::Bytes | Kind::Null,
-                        "minor": Kind::Bytes | Kind::Null,
-                        "patch": Kind::Bytes | Kind::Null,
-                        "patch_minor":  Kind::Bytes | Kind::Null,
-                    }),
-                    "device": TypeDef::new().infallible().object::<&'static str,Kind>(map!{
-                        "family": Kind::Bytes | Kind::Null,
-                        "category": Kind::Bytes | Kind::Null,
-                        "brand": Kind::Bytes | Kind::Null,
-                        "model": Kind::Bytes | Kind::Null,
-                    }),
-                }),
+            Mode::Fast | Mode::Reliable => TypeDef::object(BTreeMap::from([
+                (
+                    "browser".into(),
+                    Kind::object(BTreeMap::from([
+                        ("family".into(), Kind::bytes().or_null()),
+                        ("version".into(), Kind::bytes().or_null()),
+                    ])),
+                ),
+                (
+                    "os".into(),
+                    Kind::object(BTreeMap::from([
+                        ("family".into(), Kind::bytes().or_null()),
+                        ("version".into(), Kind::bytes().or_null()),
+                    ])),
+                ),
+                (
+                    "device".into(),
+                    Kind::object(BTreeMap::from([(
+                        "category".into(),
+                        Kind::bytes().or_null(),
+                    )])),
+                ),
+            ])),
+            Mode::Enriched => TypeDef::object(BTreeMap::from([
+                (
+                    "browser".into(),
+                    Kind::object(BTreeMap::from([
+                        ("family".into(), Kind::bytes().or_null()),
+                        ("version".into(), Kind::bytes().or_null()),
+                        ("major".into(), Kind::bytes().or_null()),
+                        ("minor".into(), Kind::bytes().or_null()),
+                        ("patch".into(), Kind::bytes().or_null()),
+                    ])),
+                ),
+                (
+                    "os".into(),
+                    Kind::object(BTreeMap::from([
+                        ("family".into(), Kind::bytes().or_null()),
+                        ("version".into(), Kind::bytes().or_null()),
+                        ("major".into(), Kind::bytes().or_null()),
+                        ("minor".into(), Kind::bytes().or_null()),
+                        ("patch".into(), Kind::bytes().or_null()),
+                        ("patch_minor".into(), Kind::bytes().or_null()),
+                    ])),
+                ),
+                (
+                    "device".into(),
+                    Kind::object(BTreeMap::from([
+                        ("family".into(), Kind::bytes().or_null()),
+                        ("category".into(), Kind::bytes().or_null()),
+                        ("brand".into(), Kind::bytes().or_null()),
+                        ("model".into(), Kind::bytes().or_null()),
+                    ])),
+                ),
+            ])),
         }
     }
 }
diff --git a/lib/vrl/stdlib/src/parse_xml.rs b/lib/vrl/stdlib/src/parse_xml.rs
index 2787dab78dcdd..478cc6c215cee 100644
--- a/lib/vrl/stdlib/src/parse_xml.rs
+++ b/lib/vrl/stdlib/src/parse_xml.rs
@@ -211,15 +211,14 @@ impl Expression for ParseXmlFn {
     }
 }
 
-fn inner_kind() -> Kind {
-    Kind::Object
-}
-
 fn type_def() -> TypeDef {
-    TypeDef::new()
+    TypeDef::bytes()
         .fallible()
-        .bytes()
-        .add_object::<(), Kind>(map! { (): inner_kind() })
+        .add_object(Collection::from_unknown(inner_kind()))
+}
+
+fn inner_kind() -> Kind {
+    Kind::object(BTreeMap::default())
 }
 
 /// Process an XML node, and return a VRL `Value`.
diff --git a/lib/vrl/stdlib/src/push.rs b/lib/vrl/stdlib/src/push.rs
index 6189597344510..d8c3db6a79917 100644
--- a/lib/vrl/stdlib/src/push.rs
+++ b/lib/vrl/stdlib/src/push.rs
@@ -79,19 +79,19 @@ impl Expression for PushFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        let item = TypeDef::new()
-            .infallible()
-            .array_mapped::<i32, TypeDef>(map! {
-                0: self.item.type_def(state),
-            });
+        let item = TypeDef::array(BTreeMap::from([(
+            0.into(),
+            self.item.type_def(state).into(),
+        )]));
 
-        self.value.type_def(state).merge(item).infallible()
+        self.value.type_def(state).merge_append(item).infallible()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use vector_common::btreemap;
 
     test_function![
         push => Push;
@@ -99,30 +99,30 @@ mod tests {
         empty_array {
             args: func_args![value: value!([]), item: value!("foo")],
             want: Ok(value!(["foo"])),
-            tdef: TypeDef::new().array_mapped::<i32, Kind>(map! {
-                0: Kind::Bytes,
+            tdef: TypeDef::array(btreemap! {
+                Index::from(0) => Kind::bytes(),
             }),
         }
 
         new_item {
             args: func_args![value: value!([11, false, 42.5]), item: value!("foo")],
             want: Ok(value!([11, false, 42.5, "foo"])),
-            tdef: TypeDef::new().array_mapped::<i32, Kind>(map! {
-                0: Kind::Integer,
-                1: Kind::Boolean,
-                2: Kind::Float,
-                3: Kind::Bytes,
+            tdef: TypeDef::array(btreemap! {
+                Index::from(0) => Kind::integer(),
+                Index::from(1) => Kind::boolean(),
+                Index::from(2) => Kind::float(),
+                Index::from(3) => Kind::bytes(),
             }),
         }
 
         already_exists_item {
             args: func_args![value: value!([11, false, 42.5]), item: value!(42.5)],
             want: Ok(value!([11, false, 42.5, 42.5])),
-            tdef: TypeDef::new().array_mapped::<i32, Kind>(map! {
-                0: Kind::Integer,
-                1: Kind::Boolean,
-                2: Kind::Float,
-                3: Kind::Float,
+            tdef: TypeDef::array(btreemap! {
+                Index::from(0) => Kind::integer(),
+                Index::from(1) => Kind::boolean(),
+                Index::from(2) => Kind::float(),
+                Index::from(3) => Kind::float(),
             }),
         }
     ];
diff --git a/lib/vrl/stdlib/src/redact.rs b/lib/vrl/stdlib/src/redact.rs
index 91ad5418526ac..e00163b229161 100644
--- a/lib/vrl/stdlib/src/redact.rs
+++ b/lib/vrl/stdlib/src/redact.rs
@@ -283,7 +283,7 @@ mod test {
                  filters: vec![Regex::new(r"\d+").unwrap()],
              ],
              want: Ok("hello [REDACTED] world"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
         }
 
         patterns {
@@ -297,7 +297,7 @@ mod test {
                  ],
              ],
              want: Ok("hello [REDACTED] world"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
         }
 
         us_social_security_number{
@@ -306,7 +306,7 @@ mod test {
                  filters: vec!["us_social_security_number"],
              ],
              want: Ok("hello [REDACTED] world"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
         }
 
         invalid_filter {
@@ -315,7 +315,7 @@ mod test {
                  filters: vec!["not a filter"],
              ],
              want: Err("invalid argument"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
         }
 
         missing_patterns {
@@ -328,7 +328,7 @@ mod test {
                  ],
              ],
              want: Err("invalid argument"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/remove.rs b/lib/vrl/stdlib/src/remove.rs
index 8f24d9e6be302..73b53ffacbb61 100644
--- a/lib/vrl/stdlib/src/remove.rs
+++ b/lib/vrl/stdlib/src/remove.rs
@@ -1,5 +1,4 @@
 use lookup_lib::{LookupBuf, SegmentBuf};
-use vector_common::btreemap;
 use vrl::prelude::*;
 
 #[derive(Clone, Copy, Debug)]
@@ -97,7 +96,7 @@ impl Function for Remove {
                 title: "invalid segment type",
                 source: r#"remove!(value: {"foo": { "bar": [92, 42] }}, path: ["foo", true])"#,
                 result: Err(
-                    r#"function call error for "remove" at (0:65): path segment must be either "string" or "integer", not "boolean""#,
+                    r#"function call error for "remove" at (0:65): path segment must be either string or integer, not boolean"#,
                 ),
             },
         ]
@@ -142,7 +141,7 @@ impl Expression for RemoveFn {
                         Value::Integer(index) => SegmentBuf::Index(index as isize),
                         value => {
                             return Err(format!(
-                                r#"path segment must be either "string" or "integer", not {}"#,
+                                r#"path segment must be either string or integer, not {}"#,
                                 value.kind()
                             )
                             .into())
@@ -157,7 +156,7 @@ impl Expression for RemoveFn {
             value => {
                 return Err(value::Error::Expected {
                     got: value.kind(),
-                    expected: Kind::Array,
+                    expected: Kind::array(Collection::any()),
                 }
                 .into())
             }
@@ -172,18 +171,19 @@ impl Expression for RemoveFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        let kind = self.value.type_def(state).kind();
+        let value_td = self.value.type_def(state);
 
-        let td = TypeDef::new().fallible();
+        let mut td = TypeDef::from(Kind::empty()).fallible();
 
-        match kind {
-            Kind::Array => td.array::<Kind>(vec![]),
-            Kind::Object => td.object::<(), Kind>(btreemap! {}),
-            k if k.contains_array() && k.contains_object() => td
-                .array::<Kind>(vec![])
-                .add_object::<(), Kind>(btreemap! {}),
-            _ => unreachable!("compiler guaranteed"),
-        }
+        if value_td.is_array() {
+            td = td.add_array(Collection::any())
+        };
+
+        if value_td.is_object() {
+            td = td.add_object(Collection::any())
+        };
+
+        td
     }
 }
 
@@ -197,13 +197,13 @@ mod tests {
         array {
             args: func_args![value: value!([42]), path: value!([0])],
             want: Ok(value!([])),
-            tdef: TypeDef::new().array::<Kind>(vec![]).fallible(),
+            tdef: TypeDef::array(Collection::any()).fallible(),
         }
 
         object {
             args: func_args![value: value!({ "foo": 42 }), path: value!(["foo"])],
             want: Ok(value!({})),
-            tdef: TypeDef::new().object::<(), Kind>(btreemap!{}).fallible(),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/replace.rs b/lib/vrl/stdlib/src/replace.rs
index aff1bec863fb2..800850f48eeb4 100644
--- a/lib/vrl/stdlib/src/replace.rs
+++ b/lib/vrl/stdlib/src/replace.rs
@@ -121,14 +121,14 @@ impl Expression for ReplaceFn {
             }
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Regex | Kind::Bytes,
+                expected: Kind::regex() | Kind::bytes(),
             }
             .into()),
         })
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -146,7 +146,7 @@ mod test {
                               with: "o"
              ],
              want: Ok("I like opples ond bononos"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_string2 {
@@ -156,7 +156,7 @@ mod test {
                               count: -1
              ],
              want: Ok("I like opples ond bononos"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_string3 {
@@ -166,7 +166,7 @@ mod test {
                               count: 0
              ],
              want: Ok("I like apples and bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_string4 {
@@ -176,7 +176,7 @@ mod test {
                               count: 1
              ],
              want: Ok("I like opples and bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_string5 {
@@ -186,7 +186,7 @@ mod test {
                               count: 2
              ],
              want: Ok("I like opples ond bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
 
@@ -196,7 +196,7 @@ mod test {
                               with: "o"
              ],
              want: Ok("I like opples ond bononos"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
 
@@ -207,7 +207,7 @@ mod test {
                               count: -1
              ],
              want: Ok("I like opples ond bononos"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_regex3 {
@@ -217,7 +217,7 @@ mod test {
                               count: 0
              ],
              want: Ok("I like apples and bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_regex4 {
@@ -227,7 +227,7 @@ mod test {
                               count: 1
              ],
              want: Ok("I like opples and bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_regex5 {
@@ -237,7 +237,7 @@ mod test {
                               count: 2
              ],
              want: Ok("I like opples ond bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_other {
@@ -246,7 +246,7 @@ mod test {
                              with: "biscuits"
             ],
              want: Ok( "I like biscuits and bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_other2 {
@@ -256,7 +256,7 @@ mod test {
                               count: 1
              ],
              want: Ok("I like opples and bananas"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         replace_other3 {
@@ -265,7 +265,7 @@ mod test {
                              with: "biscuits"
             ],
             want: Ok("I like biscuits and bananas"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/reverse_dns.rs b/lib/vrl/stdlib/src/reverse_dns.rs
index 12f11f123c27c..998d7829fc078 100644
--- a/lib/vrl/stdlib/src/reverse_dns.rs
+++ b/lib/vrl/stdlib/src/reverse_dns.rs
@@ -59,8 +59,8 @@ impl Expression for ReverseDnsFn {
         Ok(host.into())
     }
 
-    fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value.type_def(state).fallible().bytes()
+    fn type_def(&self, _: &state::Compiler) -> TypeDef {
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -74,25 +74,25 @@ mod tests {
         invalid_ip {
             args: func_args![value: value!("999.999.999.999")],
             want: Err("unable to parse IP address: invalid IP address syntax"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         google_ipv4 {
             args: func_args![value: value!("8.8.8.8")],
             want: Ok(value!("dns.google")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         google_ipv6 {
             args: func_args![value: value!("2001:4860:4860::8844")],
             want: Ok(value!("dns.google")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_type {
             args: func_args![value: value!(1)],
-            want: Err("expected \"string\", got \"integer\""),
-            tdef: TypeDef::new().fallible().bytes(),
+            want: Err("expected string, got integer"),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/round.rs b/lib/vrl/stdlib/src/round.rs
index bfb661a4ae809..3673712171b63 100644
--- a/lib/vrl/stdlib/src/round.rs
+++ b/lib/vrl/stdlib/src/round.rs
@@ -73,14 +73,14 @@ impl Expression for RoundFn {
             value @ Value::Integer(_) => Ok(value),
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Float | Kind::Integer,
+                expected: Kind::float() | Kind::integer(),
             }
             .into()),
         }
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().integer()
+        TypeDef::integer().infallible()
     }
 }
 
@@ -94,19 +94,19 @@ mod tests {
         down {
              args: func_args![value: 1234.2],
              want: Ok(1234.0),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
 
         up {
              args: func_args![value: 1234.8],
              want: Ok(1235.0),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
 
         integer {
              args: func_args![value: 1234],
              want: Ok(1234),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
 
         precision {
@@ -114,7 +114,7 @@ mod tests {
                               precision: 1
              ],
              want: Ok(1234.4),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
 
         bigger_precision  {
@@ -122,7 +122,7 @@ mod tests {
                              precision: 4
             ],
             want: Ok(1234.5679),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         huge {
@@ -130,7 +130,7 @@ mod tests {
                               precision: 5
              ],
              want: Ok(9876543210123456789098765432101234567890987654321.98765),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/set.rs b/lib/vrl/stdlib/src/set.rs
index b22c4207aba8c..8c9b64c7f0a84 100644
--- a/lib/vrl/stdlib/src/set.rs
+++ b/lib/vrl/stdlib/src/set.rs
@@ -1,5 +1,4 @@
 use lookup_lib::{LookupBuf, SegmentBuf};
-use vector_common::btreemap;
 use vrl::prelude::*;
 
 #[derive(Clone, Copy, Debug)]
@@ -77,7 +76,7 @@ impl Function for Set {
                 title: "invalid segment type",
                 source: r#"set!({"foo": { "bar": [92, 42] }}, ["foo", true], "baz")"#,
                 result: Err(
-                    r#"function call error for "set" at (0:56): path segment must be either "string" or "integer", not "boolean""#,
+                    r#"function call error for "set" at (0:56): path segment must be either string or integer, not boolean"#,
                 ),
             },
         ]
@@ -118,7 +117,7 @@ impl Expression for SetFn {
                         Value::Integer(index) => SegmentBuf::Index(index as isize),
                         value => {
                             return Err(format!(
-                                r#"path segment must be either "string" or "integer", not {}"#,
+                                r#"path segment must be either string or integer, not {}"#,
                                 value.kind()
                             )
                             .into())
@@ -133,7 +132,7 @@ impl Expression for SetFn {
             value => {
                 return Err(value::Error::Expected {
                     got: value.kind(),
-                    expected: Kind::Array | Kind::Bytes,
+                    expected: Kind::array(Collection::any()) | Kind::bytes(),
                 }
                 .into())
             }
@@ -146,18 +145,19 @@ impl Expression for SetFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        let kind = self.value.type_def(state).kind();
+        let value_td = self.value.type_def(state);
 
-        let td = TypeDef::new().fallible();
+        let mut td = TypeDef::from(Kind::empty()).fallible();
 
-        match kind {
-            Kind::Array => td.array::<Kind>(vec![]),
-            Kind::Object => td.object::<(), Kind>(btreemap! {}),
-            k if k.contains_array() && k.contains_object() => td
-                .array::<Kind>(vec![])
-                .add_object::<(), Kind>(btreemap! {}),
-            _ => unreachable!("compiler guaranteed"),
-        }
+        if value_td.is_array() {
+            td = td.add_array(Collection::any())
+        };
+
+        if value_td.is_object() {
+            td = td.add_object(Collection::any())
+        };
+
+        td
     }
 }
 
@@ -171,13 +171,13 @@ mod tests {
         array {
             args: func_args![value: value!([]), path: vec![0], data: true],
             want: Ok(vec![true]),
-            tdef: TypeDef::new().array::<Kind>(vec![]).fallible(),
+            tdef: TypeDef::array(Collection::any()).fallible(),
         }
 
         object {
             args: func_args![value: value!({}), path: vec!["foo"], data: true],
             want: Ok(value!({ "foo": true })),
-            tdef: TypeDef::new().object::<(), Kind>(btreemap!{}).fallible(),
+            tdef: TypeDef::object(Collection::any()).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/sha1.rs b/lib/vrl/stdlib/src/sha1.rs
index 7d11efd7ff560..282036389281b 100644
--- a/lib/vrl/stdlib/src/sha1.rs
+++ b/lib/vrl/stdlib/src/sha1.rs
@@ -50,7 +50,7 @@ impl Expression for Sha1Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -64,7 +64,7 @@ mod tests {
         sha {
              args: func_args![value: "foo"],
              want: Ok("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/sha2.rs b/lib/vrl/stdlib/src/sha2.rs
index 1557a7b80dac5..94a159abdfc7b 100644
--- a/lib/vrl/stdlib/src/sha2.rs
+++ b/lib/vrl/stdlib/src/sha2.rs
@@ -89,7 +89,7 @@ impl Expression for Sha2Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -108,7 +108,7 @@ mod tests {
         sha2 {
              args: func_args![value: "foo"],
              want: Ok("d58042e6aa5a335e03ad576c6a9e43b41591bfd2077f72dec9df7930e492055d"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha2_224 {
@@ -116,7 +116,7 @@ mod tests {
                              variant: "SHA-224"
             ],
             want: Ok("0808f64e60d58979fcb676c96ec938270dea42445aeefcd3a4e6f8db"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         sha2_256 {
@@ -124,7 +124,7 @@ mod tests {
                               variant: "SHA-256"
              ],
              want: Ok("2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha2_385 {
@@ -132,7 +132,7 @@ mod tests {
                              variant: "SHA-384"
             ],
             want: Ok("98c11ffdfdd540676b1a137cb1a22b2a70350c9a44171d6b1180c6be5cbb2ee3f79d532c8a1dd9ef2e8e08e752a3babb"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         sha2_512 {
@@ -140,7 +140,7 @@ mod tests {
                               variant: "SHA-512"
              ],
              want: Ok("f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha2_512_224 {
@@ -148,7 +148,7 @@ mod tests {
                               variant: "SHA-512/224"
              ],
              want: Ok("d68f258d37d670cfc1ec1001a0394784233f88f056994f9a7e5e99be"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha2_512_256 {
@@ -156,7 +156,7 @@ mod tests {
                               variant: "SHA-512/256"
              ],
              want: Ok("d58042e6aa5a335e03ad576c6a9e43b41591bfd2077f72dec9df7930e492055d"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/sha3.rs b/lib/vrl/stdlib/src/sha3.rs
index e8034554a60c9..7204414994259 100644
--- a/lib/vrl/stdlib/src/sha3.rs
+++ b/lib/vrl/stdlib/src/sha3.rs
@@ -85,7 +85,7 @@ impl Expression for Sha3Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -104,13 +104,13 @@ mod tests {
         sha3 {
              args: func_args![value: "foo"],
              want: Ok("4bca2b137edc580fe50a88983ef860ebaca36c857b1f492839d6d7392452a63c82cbebc68e3b70a2a1480b4bb5d437a7cba6ecf9d89f9ff3ccd14cd6146ea7e7"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha3_224  {
             args: func_args![value: "foo"],
             want: Ok("4bca2b137edc580fe50a88983ef860ebaca36c857b1f492839d6d7392452a63c82cbebc68e3b70a2a1480b4bb5d437a7cba6ecf9d89f9ff3ccd14cd6146ea7e7"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         sha3_256 {
@@ -118,7 +118,7 @@ mod tests {
                               variant: "SHA3-256"
              ],
              want: Ok("76d3bc41c9f588f7fcd0d5bf4718f8f84b1c41b20882703100b9eb9413807c01"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha3_384 {
@@ -126,7 +126,7 @@ mod tests {
                               variant: "SHA3-384"
              ],
              want: Ok("665551928d13b7d84ee02734502b018d896a0fb87eed5adb4c87ba91bbd6489410e11b0fbcc06ed7d0ebad559e5d3bb5"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         sha3_512 {
@@ -134,7 +134,7 @@ mod tests {
                               variant: "SHA3-512"
              ],
              want: Ok("4bca2b137edc580fe50a88983ef860ebaca36c857b1f492839d6d7392452a63c82cbebc68e3b70a2a1480b4bb5d437a7cba6ecf9d89f9ff3ccd14cd6146ea7e7"),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/slice.rs b/lib/vrl/stdlib/src/slice.rs
index 52af21f53d41d..91533f52964ca 100644
--- a/lib/vrl/stdlib/src/slice.rs
+++ b/lib/vrl/stdlib/src/slice.rs
@@ -37,7 +37,7 @@ fn slice(
             .map(Value::from),
         value => Err(value::Error::Expected {
             got: value.kind(),
-            expected: Kind::Bytes | Kind::Array,
+            expected: Kind::bytes() | Kind::array(Collection::any()),
         }
         .into()),
     }
@@ -136,14 +136,12 @@ impl Expression for SliceFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        let td = TypeDef::new().fallible();
+        let td = TypeDef::from(Kind::empty()).fallible();
 
         match self.value.type_def(state) {
-            v if v.is_bytes() => td.merge(v),
-            v if v.is_array() => td.merge(v).collect_subtypes(),
-            _ => td.bytes().add_array_mapped::<(), Kind>(map! {
-                (): Kind::all(),
-            }),
+            v if v.is_bytes() => td.merge_deep(v),
+            v if v.is_array() => td.merge_deep(v).collect_subtypes(),
+            _ => td.add_bytes().add_array(Collection::any()),
         }
     }
 }
@@ -160,7 +158,7 @@ mod tests {
                              start: 0
             ],
             want: Ok("foo"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_1 {
@@ -168,7 +166,7 @@ mod tests {
                              start: 1
             ],
             want: Ok("oo"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_2 {
@@ -176,7 +174,7 @@ mod tests {
                              start: 2
             ],
             want: Ok("o"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_minus_2 {
@@ -184,7 +182,7 @@ mod tests {
                              start: -2
             ],
             want: Ok("oo"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_empty {
@@ -192,7 +190,7 @@ mod tests {
                              start: 3
             ],
             want: Ok(""),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_empty_start_end {
@@ -201,7 +199,7 @@ mod tests {
                              end: 2
             ],
             want: Ok(""),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_overrun {
@@ -210,7 +208,7 @@ mod tests {
                              end: 4
             ],
             want: Ok("foo"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_start_overrun {
@@ -219,7 +217,7 @@ mod tests {
                              end: 5
             ],
             want: Ok("oo"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_negative  {
@@ -227,7 +225,7 @@ mod tests {
                              start: -7
             ],
             want: Ok("docious"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         bytes_middle {
@@ -236,7 +234,7 @@ mod tests {
                              end: 9
             ],
             want: Ok("cali"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         array_0 {
@@ -244,7 +242,7 @@ mod tests {
                              start: 0
             ],
             want: Ok(vec![0, 1, 2]),
-            tdef: TypeDef::new().fallible().array_mapped::<(), Kind>(map! { (): Kind::Integer }),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::integer())).fallible(),
         }
 
         array_1 {
@@ -252,7 +250,7 @@ mod tests {
                              start: 1
             ],
             want: Ok(vec![1, 2]),
-            tdef: TypeDef::new().fallible().array_mapped::<(), Kind>(map! { (): Kind::Integer }),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::integer())).fallible(),
         }
 
         array_minus_2 {
@@ -260,7 +258,7 @@ mod tests {
                              start: -2
             ],
             want: Ok(vec![1, 2]),
-            tdef: TypeDef::new().fallible().array_mapped::<(), Kind>(map! { (): Kind::Integer }),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::integer())).fallible(),
         }
 
         array_mixed_types {
@@ -268,9 +266,7 @@ mod tests {
                              start: 1
             ],
             want: Ok(value!(["ook", true])),
-            tdef: TypeDef::new().fallible().array_mapped::<(), Kind>(
-                map! { (): Kind::Integer | Kind::Bytes | Kind::Boolean }
-            ),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::integer().or_bytes().or_boolean())).fallible(),
         }
 
         error_after_end {
@@ -278,7 +274,7 @@ mod tests {
                              start: 4
             ],
             want: Err(r#""start" must be between "-3" and "3""#),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         error_minus_before_start {
@@ -286,7 +282,7 @@ mod tests {
                              start: -4
             ],
             want: Err(r#""start" must be between "-3" and "3""#),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         error_start_end {
@@ -295,7 +291,7 @@ mod tests {
                              end: 1
             ],
             want: Err(r#""end" must be greater or equal to "start""#),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/split.rs b/lib/vrl/stdlib/src/split.rs
index ecb8aabbf402a..761a3508f6d47 100644
--- a/lib/vrl/stdlib/src/split.rs
+++ b/lib/vrl/stdlib/src/split.rs
@@ -94,16 +94,14 @@ impl Expression for SplitFn {
             }
             value => Err(value::Error::Expected {
                 got: value.kind(),
-                expected: Kind::Regex | Kind::Bytes,
+                expected: Kind::regex() | Kind::bytes(),
             }
             .into()),
         })
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .infallible()
-            .array_mapped::<(), Kind>(map! {(): Kind::Bytes})
+        TypeDef::array(Collection::from_unknown(Kind::bytes())).infallible()
     }
 }
 
@@ -120,9 +118,7 @@ mod test {
                              pattern: " "
             ],
             want: Ok(value!([""])),
-            tdef: TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! {(): Kind::Bytes}),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
         }
 
         single {
@@ -130,9 +126,7 @@ mod test {
                              pattern: " "
             ],
             want: Ok(value!(["foo"])),
-            tdef: TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! {(): Kind::Bytes}),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
         }
 
         long {
@@ -140,9 +134,7 @@ mod test {
                              pattern: " "
             ],
             want: Ok(value!(["This", "is", "a", "long", "string."])),
-            tdef: TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! {(): Kind::Bytes}),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
         }
 
         regex {
@@ -151,9 +143,7 @@ mod test {
                              limit: 2
             ],
             want: Ok(value!(["This", "is a long string"])),
-            tdef: TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! {(): Kind::Bytes}),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
         }
 
         non_space {
@@ -161,9 +151,7 @@ mod test {
                              pattern: Value::Regex(regex::Regex::new("(?i)a").unwrap().into())
             ],
             want: Ok(value!(["This", "is", "long", "string."])),
-            tdef: TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! {(): Kind::Bytes}),
+            tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
         }
 
         unicode {
@@ -171,9 +159,7 @@ mod test {
                               pattern: " "
              ],
              want: Ok(value!(["˙ƃuᴉɹʇs", "ƃuol", "ɐ", "sᴉ", "sᴉɥ┴"])),
-             tdef: TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! {(): Kind::Bytes}),
+             tdef: TypeDef::array(Collection::from_unknown(Kind::bytes())),
          }
 
     ];
diff --git a/lib/vrl/stdlib/src/starts_with.rs b/lib/vrl/stdlib/src/starts_with.rs
index 3986680e6d6fa..6524ec0f08d0f 100644
--- a/lib/vrl/stdlib/src/starts_with.rs
+++ b/lib/vrl/stdlib/src/starts_with.rs
@@ -189,7 +189,7 @@ impl Expression for StartsWithFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().boolean()
+        TypeDef::boolean().infallible()
     }
 }
 
@@ -205,7 +205,7 @@ mod tests {
                              substring: "bar"
             ],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         subset {
@@ -213,7 +213,7 @@ mod tests {
                              substring: "foobar"
             ],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         total {
@@ -221,7 +221,7 @@ mod tests {
                              substring: "foo"
             ],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         middle {
@@ -229,7 +229,7 @@ mod tests {
                              substring: "oba"
             ],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         start {
@@ -237,7 +237,7 @@ mod tests {
                              substring: "foo"
             ],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         end {
@@ -245,7 +245,7 @@ mod tests {
                              substring: "bar"
             ],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
 
@@ -254,7 +254,7 @@ mod tests {
                              substring: "FOO"
             ],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_sensitive_different_case {
@@ -262,7 +262,7 @@ mod tests {
                              substring: "FOO"
             ],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         case_insensitive_different_case {
@@ -271,7 +271,7 @@ mod tests {
                              case_sensitive: false
             ],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         unicode_same_case {
@@ -280,7 +280,7 @@ mod tests {
                              case_sensitive: true
             ],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         unicode_sensitive_different_case {
@@ -289,7 +289,7 @@ mod tests {
                              case_sensitive: true
             ],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         unicode_insensitive_different_case {
@@ -298,7 +298,7 @@ mod tests {
                              case_sensitive: false
             ],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/string.rs b/lib/vrl/stdlib/src/string.rs
index d9f7458c99189..fb33007ed9fb4 100644
--- a/lib/vrl/stdlib/src/string.rs
+++ b/lib/vrl/stdlib/src/string.rs
@@ -3,7 +3,7 @@ use vrl::prelude::*;
 fn string(value: Value) -> std::result::Result<Value, ExpressionError> {
     match value {
         v @ Value::Bytes(_) => Ok(v),
-        v => Err(format!(r#"expected "string", got {}"#, v.kind()).into()),
+        v => Err(format!("expected string, got {}", v.kind()).into()),
     }
 }
 
@@ -34,7 +34,7 @@ impl Function for String {
                 title: "invalid",
                 source: "string!(true)",
                 result: Err(
-                    r#"function call error for "string" at (0:13): expected "string", got "boolean""#,
+                    r#"function call error for "string" at (0:13): expected string, got boolean"#,
                 ),
             },
         ]
@@ -68,9 +68,8 @@ impl Expression for StringFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value
-            .type_def(state)
-            .fallible_unless(Kind::Bytes)
-            .bytes()
+        let non_bytes = !self.value.type_def(state).is_bytes();
+
+        TypeDef::bytes().with_fallibility(non_bytes)
     }
 }
diff --git a/lib/vrl/stdlib/src/strip_ansi_escape_codes.rs b/lib/vrl/stdlib/src/strip_ansi_escape_codes.rs
index 55827933e2554..a38f2ffe72ad7 100644
--- a/lib/vrl/stdlib/src/strip_ansi_escape_codes.rs
+++ b/lib/vrl/stdlib/src/strip_ansi_escape_codes.rs
@@ -53,7 +53,7 @@ impl Expression for StripAnsiEscapeCodesFn {
         // We're marking this as infallible, because `strip_ansi_escapes` only
         // fails if it can't write to the buffer, which is highly unlikely to
         // occur.
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -67,25 +67,25 @@ mod tests {
         no_codes {
             args: func_args![value: "foo bar"],
             want: Ok("foo bar"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         strip_1 {
             args: func_args![value: "\x1b[3;4Hfoo bar"],
             want: Ok("foo bar"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         strip_2 {
             args: func_args![value: "\x1b[46mfoo\x1b[0m bar"],
             want: Ok("foo bar"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         strip_3 {
             args: func_args![value: "\x1b[=3lfoo bar"],
             want: Ok("foo bar"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/strip_whitespace.rs b/lib/vrl/stdlib/src/strip_whitespace.rs
index cbb98edfd8470..a86ae5f33a4c5 100644
--- a/lib/vrl/stdlib/src/strip_whitespace.rs
+++ b/lib/vrl/stdlib/src/strip_whitespace.rs
@@ -67,7 +67,7 @@ impl Expression for StripWhitespaceFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -81,31 +81,31 @@ mod tests {
         empty {
             args: func_args![value: ""],
             want: Ok(""),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         just_spaces {
             args: func_args![value: "      "],
             want: Ok(""),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         no_spaces {
             args: func_args![value: "hi there"],
             want: Ok("hi there"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         spaces {
             args: func_args![value: "           hi there        "],
             want: Ok("hi there"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         unicode_whitespace {
             args: func_args![value: " \u{3000}\u{205F}\u{202F}\u{A0}\u{9} ❤❤ hi there ❤❤  \u{9}\u{A0}\u{202F}\u{205F}\u{3000} "],
             want: Ok("❤❤ hi there ❤❤"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/tag_types_externally.rs b/lib/vrl/stdlib/src/tag_types_externally.rs
index dfd1644398173..9680de228db8a 100644
--- a/lib/vrl/stdlib/src/tag_types_externally.rs
+++ b/lib/vrl/stdlib/src/tag_types_externally.rs
@@ -79,14 +79,10 @@ impl Expression for TagTypesExternallyFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        match self.value.type_def(state).kind() {
-            kind if kind.is_array() => TypeDef::new()
-                .infallible()
-                .array_mapped::<(), Kind>(map! { (): Kind::all() }),
-            kind if kind.is_null() => TypeDef::new().infallible().null(),
-            _ => TypeDef::new()
-                .infallible()
-                .object::<(), Kind>(map! { (): Kind::all() }),
+        match self.value.type_def(state) {
+            td if td.is_array() => TypeDef::array(Collection::any()),
+            td if td.is_null() => TypeDef::null(),
+            _ => TypeDef::object(Collection::any()),
         }
     }
 }
@@ -144,7 +140,7 @@ mod tests {
             want: Ok(btreemap! {
                 "string" => "foo",
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_integer {
@@ -152,7 +148,7 @@ mod tests {
             want: Ok(btreemap! {
                 "integer" => 123
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_float {
@@ -160,7 +156,7 @@ mod tests {
             want: Ok(btreemap! {
                 "float" => 123.45
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_boolean {
@@ -168,7 +164,7 @@ mod tests {
             want: Ok(btreemap! {
                 "boolean" => true
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_map {
@@ -178,7 +174,7 @@ mod tests {
                     "string" => "bar"
                 }
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_array {
@@ -188,7 +184,7 @@ mod tests {
                     "string" => "foo"
                 },
             ]),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         tag_timestamp {
@@ -196,7 +192,7 @@ mod tests {
             want: Ok(btreemap! {
                 "timestamp" => Utc.ymd(2021, 1, 1).and_hms_milli(0, 0, 0, 0)
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_regex {
@@ -204,13 +200,13 @@ mod tests {
             want: Ok(btreemap! {
                 "regex" => Regex::new(".*").unwrap()
             }),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::object(Collection::any()),
         }
 
         tag_null {
             args: func_args![value: Value::Null],
             want: Ok(Value::Null),
-            tdef: TypeDef::new().null(),
+            tdef: TypeDef::null(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/tally.rs b/lib/vrl/stdlib/src/tally.rs
index a343c636bc229..1d6a78e24ffcb 100644
--- a/lib/vrl/stdlib/src/tally.rs
+++ b/lib/vrl/stdlib/src/tally.rs
@@ -66,9 +66,7 @@ impl Expression for TallyFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .object::<(), Kind>(map! { (): Kind::Integer })
-            .fallible()
+        TypeDef::object(Collection::from_unknown(Kind::integer())).fallible()
     }
 }
 
@@ -84,7 +82,7 @@ mod tests {
                 value: value!(["bar", "foo", "baz", "foo"]),
             ],
             want: Ok(value!({"bar": 1, "foo": 2, "baz": 1})),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::Integer }).fallible(),
+            tdef: TypeDef::object(Collection::from_unknown(Kind::integer())).fallible(),
         }
 
         non_string_values {
@@ -92,7 +90,7 @@ mod tests {
                 value: value!(["foo", [1,2,3], "123abc", 1, true, [1,2,3], "foo", true, 1]),
             ],
             want: Err("all values must be strings, found: Array([Integer(1), Integer(2), Integer(3)])"),
-            tdef: TypeDef::new().object::<(), Kind>(map! { (): Kind::Integer }).fallible(),
+            tdef: TypeDef::object(Collection::from_unknown(Kind::integer())).fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/tally_value.rs b/lib/vrl/stdlib/src/tally_value.rs
index c1bee8af19f6f..c95f8bb89d93b 100644
--- a/lib/vrl/stdlib/src/tally_value.rs
+++ b/lib/vrl/stdlib/src/tally_value.rs
@@ -59,7 +59,7 @@ impl Expression for TallyValueFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().integer()
+        TypeDef::integer().infallible()
     }
 }
 
@@ -76,7 +76,7 @@ mod tests {
                 value: value!("foo"),
             ],
             want: Ok(value!(2)),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/timestamp.rs b/lib/vrl/stdlib/src/timestamp.rs
index 2a3140291cbbc..410c1c114a421 100644
--- a/lib/vrl/stdlib/src/timestamp.rs
+++ b/lib/vrl/stdlib/src/timestamp.rs
@@ -27,7 +27,7 @@ impl Function for Timestamp {
                 title: "invalid",
                 source: "timestamp!(true)",
                 result: Err(
-                    r#"function call error for "timestamp" at (0:16): expected "timestamp", got "boolean""#,
+                    r#"function call error for "timestamp" at (0:16): expected timestamp, got boolean"#,
                 ),
             },
         ]
@@ -54,14 +54,13 @@ impl Expression for TimestampFn {
     fn resolve(&self, ctx: &mut Context) -> Resolved {
         match self.value.resolve(ctx)? {
             v @ Value::Timestamp(_) => Ok(v),
-            v => Err(format!(r#"expected "timestamp", got {}"#, v.kind()).into()),
+            v => Err(format!(r#"expected timestamp, got {}"#, v.kind()).into()),
         }
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value
-            .type_def(state)
-            .fallible_unless(Kind::Timestamp)
-            .timestamp()
+        let non_timestamp = !self.value.type_def(state).is_timestamp();
+
+        TypeDef::timestamp().with_fallibility(non_timestamp)
     }
 }
diff --git a/lib/vrl/stdlib/src/to_bool.rs b/lib/vrl/stdlib/src/to_bool.rs
index de2a1db1e787c..8c9bc9f007cd8 100644
--- a/lib/vrl/stdlib/src/to_bool.rs
+++ b/lib/vrl/stdlib/src/to_bool.rs
@@ -12,7 +12,7 @@ fn to_bool(value: Value) -> std::result::Result<Value, ExpressionError> {
         Bytes(v) => Conversion::Boolean
             .convert(v)
             .map_err(|e| e.to_string().into()),
-        v => Err(format!(r#"unable to coerce {} into "boolean""#, v.kind()).into()),
+        v => Err(format!("unable to coerce {} into boolean", v.kind()).into()),
     }
 }
 
@@ -120,28 +120,28 @@ impl Function for ToBool {
                 title: "timestamp",
                 source: "to_bool!(t'2020-01-01T00:00:00Z')",
                 result: Err(
-                    r#"function call error for "to_bool" at (0:33): unable to coerce "timestamp" into "boolean""#,
+                    r#"function call error for "to_bool" at (0:33): unable to coerce timestamp into boolean"#,
                 ),
             },
             Example {
                 title: "array",
                 source: "to_bool!([])",
                 result: Err(
-                    r#"function call error for "to_bool" at (0:12): unable to coerce "array" into "boolean""#,
+                    r#"function call error for "to_bool" at (0:12): unable to coerce array into boolean"#,
                 ),
             },
             Example {
                 title: "object",
                 source: "to_bool!({})",
                 result: Err(
-                    r#"function call error for "to_bool" at (0:12): unable to coerce "object" into "boolean""#,
+                    r#"function call error for "to_bool" at (0:12): unable to coerce object into boolean"#,
                 ),
             },
             Example {
                 title: "regex",
                 source: "to_bool!(r'foo')",
                 result: Err(
-                    r#"function call error for "to_bool" at (0:16): unable to coerce "regex" into "boolean""#,
+                    r#"function call error for "to_bool" at (0:16): unable to coerce regex into boolean"#,
                 ),
             },
         ]
@@ -178,13 +178,15 @@ impl Expression for ToBoolFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .with_fallibility(
-                self.value.type_def(state).has_kind(
-                    Kind::Bytes | Kind::Timestamp | Kind::Array | Kind::Object | Kind::Regex,
-                ),
-            )
-            .boolean()
+        let td = self.value.type_def(state);
+
+        TypeDef::boolean().with_fallibility(
+            td.contains_bytes()
+                || td.contains_timestamp()
+                || td.contains_array()
+                || td.contains_object()
+                || td.contains_regex(),
+        )
     }
 }
 
@@ -198,31 +200,31 @@ mod tests {
         string_true {
             args: func_args![value: "true"],
             want: Ok(true),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         string_false {
             args: func_args![value: "no"],
             want: Ok(false),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         string_error {
             args: func_args![value: "cabbage"],
             want: Err(r#"Invalid boolean value "cabbage""#),
-            tdef: TypeDef::new().fallible().boolean(),
+            tdef: TypeDef::boolean().fallible(),
         }
 
         number_true {
             args: func_args![value: 20],
             want: Ok(true),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
 
         number_false {
             args: func_args![value: 0],
             want: Ok(false),
-            tdef: TypeDef::new().infallible().boolean(),
+            tdef: TypeDef::boolean().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_float.rs b/lib/vrl/stdlib/src/to_float.rs
index ab9761e585222..daa8b7653ca8c 100644
--- a/lib/vrl/stdlib/src/to_float.rs
+++ b/lib/vrl/stdlib/src/to_float.rs
@@ -12,7 +12,7 @@ fn to_float(value: Value) -> std::result::Result<Value, ExpressionError> {
         Bytes(v) => Conversion::Float
             .convert(v)
             .map_err(|e| e.to_string().into()),
-        v => Err(format!(r#"unable to coerce {} into "float""#, v.kind()).into()),
+        v => Err(format!("unable to coerce {} into float", v.kind()).into()),
     }
 }
 
@@ -80,21 +80,21 @@ impl Function for ToFloat {
                 title: "array",
                 source: "to_float!([])",
                 result: Err(
-                    r#"function call error for "to_float" at (0:13): unable to coerce "array" into "float""#,
+                    r#"function call error for "to_float" at (0:13): unable to coerce array into float"#,
                 ),
             },
             Example {
                 title: "object",
                 source: "to_float!({})",
                 result: Err(
-                    r#"function call error for "to_float" at (0:13): unable to coerce "object" into "float""#,
+                    r#"function call error for "to_float" at (0:13): unable to coerce object into float"#,
                 ),
             },
             Example {
                 title: "regex",
                 source: "to_float!(r'foo')",
                 result: Err(
-                    r#"function call error for "to_float" at (0:17): unable to coerce "regex" into "float""#,
+                    r#"function call error for "to_float" at (0:17): unable to coerce regex into float"#,
                 ),
             },
         ]
@@ -131,13 +131,14 @@ impl Expression for ToFloatFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .with_fallibility(
-                self.value
-                    .type_def(state)
-                    .has_kind(Kind::Bytes | Kind::Array | Kind::Object | Kind::Regex),
-            )
-            .float()
+        let td = self.value.type_def(state);
+
+        TypeDef::float().with_fallibility(
+            td.contains_bytes()
+                || td.contains_array()
+                || td.contains_object()
+                || td.contains_regex(),
+        )
     }
 }
 
@@ -153,19 +154,19 @@ mod tests {
         float {
             args: func_args![value: 20.5],
             want: Ok(20.5),
-            tdef: TypeDef::new().infallible().float(),
+            tdef: TypeDef::float().infallible(),
         }
 
         integer {
             args: func_args![value: 20],
             want: Ok(20.0),
-            tdef: TypeDef::new().infallible().float(),
+            tdef: TypeDef::float().infallible(),
         }
 
         timestamp {
              args: func_args![value: Utc.ymd(2014, 7, 8).and_hms_milli(9, 10, 11, 12)],
              want: Ok(1404810611.012),
-             tdef: TypeDef::new().infallible().float(),
+             tdef: TypeDef::float().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_int.rs b/lib/vrl/stdlib/src/to_int.rs
index 946e8b55d5ff1..e31f139279ff8 100644
--- a/lib/vrl/stdlib/src/to_int.rs
+++ b/lib/vrl/stdlib/src/to_int.rs
@@ -13,7 +13,7 @@ fn to_int(value: Value) -> std::result::Result<Value, ExpressionError> {
             .convert(v)
             .map_err(|e| e.to_string().into()),
         Timestamp(v) => Ok(v.timestamp().into()),
-        v => Err(format!(r#"unable to coerce {} into "integer""#, v.kind()).into()),
+        v => Err(format!("unable to coerce {} into integer", v.kind()).into()),
     }
 }
 
@@ -81,21 +81,21 @@ impl Function for ToInt {
                 title: "array",
                 source: "to_int!([])",
                 result: Err(
-                    r#"function call error for "to_int" at (0:11): unable to coerce "array" into "integer""#,
+                    r#"function call error for "to_int" at (0:11): unable to coerce array into integer"#,
                 ),
             },
             Example {
                 title: "object",
                 source: "to_int!({})",
                 result: Err(
-                    r#"function call error for "to_int" at (0:11): unable to coerce "object" into "integer""#,
+                    r#"function call error for "to_int" at (0:11): unable to coerce object into integer"#,
                 ),
             },
             Example {
                 title: "regex",
                 source: "to_int!(r'foo')",
                 result: Err(
-                    r#"function call error for "to_int" at (0:15): unable to coerce "regex" into "integer""#,
+                    r#"function call error for "to_int" at (0:15): unable to coerce regex into integer"#,
                 ),
             },
         ]
@@ -132,13 +132,14 @@ impl Expression for ToIntFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        TypeDef::new()
-            .with_fallibility(
-                self.value
-                    .type_def(state)
-                    .has_kind(Kind::Bytes | Kind::Array | Kind::Object | Kind::Regex),
-            )
-            .integer()
+        let td = self.value.type_def(state);
+
+        TypeDef::integer().with_fallibility(
+            td.contains_bytes()
+                || td.contains_array()
+                || td.contains_object()
+                || td.contains_regex(),
+        )
     }
 }
 
@@ -154,13 +155,13 @@ mod tests {
         string {
              args: func_args![value: "20"],
              want: Ok(20),
-             tdef: TypeDef::new().fallible().integer(),
+             tdef: TypeDef::integer().fallible(),
         }
 
         float {
              args: func_args![value: 20.5],
              want: Ok(20),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
         }
 
         timezone {
@@ -168,7 +169,7 @@ mod tests {
                             .unwrap()
                             .with_timezone(&Utc)],
              want: Ok(1571227200),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_regex.rs b/lib/vrl/stdlib/src/to_regex.rs
index 552542e96a487..3bd849f75698f 100644
--- a/lib/vrl/stdlib/src/to_regex.rs
+++ b/lib/vrl/stdlib/src/to_regex.rs
@@ -62,8 +62,8 @@ impl Expression for ToRegexFn {
         to_regex(value)
     }
 
-    fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value.type_def(state).fallible().regex()
+    fn type_def(&self, _: &state::Compiler) -> TypeDef {
+        TypeDef::regex().fallible()
     }
 }
 
@@ -77,13 +77,13 @@ mod tests {
         regex {
             args: func_args![value: "^test[A-Za-z_]+$"],
             want: Ok(regex::Regex::new("^test[A-Za-z_]+$").expect("regex is valid")),
-            tdef: TypeDef::new().fallible().regex(),
+            tdef: TypeDef::regex().fallible(),
         }
 
         invalid_regex {
             args: func_args![value: "(+)"],
             want: Err("could not create regex: regex parse error:\n    (+)\n     ^\nerror: repetition operator missing expression"),
-            tdef: TypeDef::new().fallible().regex(),
+            tdef: TypeDef::regex().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_string.rs b/lib/vrl/stdlib/src/to_string.rs
index f26cf9673c01e..a3a776d74b801 100644
--- a/lib/vrl/stdlib/src/to_string.rs
+++ b/lib/vrl/stdlib/src/to_string.rs
@@ -10,7 +10,7 @@ fn to_string(value: Value) -> std::result::Result<Value, ExpressionError> {
         Boolean(v) => v.to_string().into(),
         Timestamp(v) => v.to_rfc3339_opts(SecondsFormat::AutoSi, true).into(),
         Null => "".into(),
-        v => return Err(format!(r#"unable to coerce {} into "string""#, v.kind()).into()),
+        v => return Err(format!("unable to coerce {} into string", v.kind()).into()),
     };
     Ok(value)
 }
@@ -72,21 +72,21 @@ impl Function for ToString {
                 title: "array",
                 source: "to_string!([])",
                 result: Err(
-                    r#"function call error for "to_string" at (0:14): unable to coerce "array" into "string""#,
+                    r#"function call error for "to_string" at (0:14): unable to coerce array into string"#,
                 ),
             },
             Example {
                 title: "object",
                 source: "to_string!({})",
                 result: Err(
-                    r#"function call error for "to_string" at (0:14): unable to coerce "object" into "string""#,
+                    r#"function call error for "to_string" at (0:14): unable to coerce object into string"#,
                 ),
             },
             Example {
                 title: "regex",
                 source: "to_string!(r'foo')",
                 result: Err(
-                    r#"function call error for "to_string" at (0:18): unable to coerce "regex" into "string""#,
+                    r#"function call error for "to_string" at (0:18): unable to coerce regex into string"#,
                 ),
             },
         ]
@@ -123,17 +123,10 @@ impl Expression for ToStringFn {
     }
 
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        self.value
-            .type_def(state)
-            .fallible_unless(
-                Kind::Bytes
-                    | Kind::Integer
-                    | Kind::Float
-                    | Kind::Boolean
-                    | Kind::Null
-                    | Kind::Timestamp,
-            )
-            .bytes()
+        let td = self.value.type_def(state);
+
+        TypeDef::bytes()
+            .with_fallibility(td.contains_array() || td.contains_object() || td.contains_regex())
     }
 }
 
@@ -147,13 +140,13 @@ mod tests {
         integer {
             args: func_args![value: 20],
             want: Ok("20"),
-            tdef: TypeDef::new().bytes(),
+            tdef: TypeDef::bytes(),
         }
 
         float {
             args: func_args![value: 20.5],
             want: Ok("20.5"),
-            tdef: TypeDef::new().bytes(),
+            tdef: TypeDef::bytes(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_syslog_facility.rs b/lib/vrl/stdlib/src/to_syslog_facility.rs
index 066c95556c691..4ebce2a40092f 100644
--- a/lib/vrl/stdlib/src/to_syslog_facility.rs
+++ b/lib/vrl/stdlib/src/to_syslog_facility.rs
@@ -87,7 +87,7 @@ impl Expression for ToSyslogFacilityFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -101,163 +101,163 @@ mod tests {
         kern {
             args: func_args![value: value!(0)],
             want: Ok(value!("kern")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         user {
             args: func_args![value: value!(1)],
             want: Ok(value!("user")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         mail {
             args: func_args![value: value!(2)],
             want: Ok(value!("mail")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         daemon {
             args: func_args![value: value!(3)],
             want: Ok(value!("daemon")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         auth {
             args: func_args![value: value!(4)],
             want: Ok(value!("auth")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         syslog {
             args: func_args![value: value!(5)],
             want: Ok(value!("syslog")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         lpr {
             args: func_args![value: value!(6)],
             want: Ok(value!("lpr")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         news {
             args: func_args![value: value!(7)],
             want: Ok(value!("news")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         uucp {
             args: func_args![value: value!(8)],
             want: Ok(value!("uucp")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         cron {
             args: func_args![value: value!(9)],
             want: Ok(value!("cron")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         authpriv {
             args: func_args![value: value!(10)],
             want: Ok(value!("authpriv")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ftp {
             args: func_args![value: value!(11)],
             want: Ok(value!("ftp")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         ntp {
             args: func_args![value: value!(12)],
             want: Ok(value!("ntp")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         security {
             args: func_args![value: value!(13)],
             want: Ok(value!("security")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         console {
             args: func_args![value: value!(14)],
             want: Ok(value!("console")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         solaris_cron {
             args: func_args![value: value!(15)],
             want: Ok(value!("solaris-cron")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local0 {
             args: func_args![value: value!(16)],
             want: Ok(value!("local0")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local1 {
             args: func_args![value: value!(17)],
             want: Ok(value!("local1")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local2 {
             args: func_args![value: value!(18)],
             want: Ok(value!("local2")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local3 {
             args: func_args![value: value!(19)],
             want: Ok(value!("local3")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local4 {
             args: func_args![value: value!(20)],
             want: Ok(value!("local4")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local5 {
             args: func_args![value: value!(21)],
             want: Ok(value!("local5")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local6 {
             args: func_args![value: value!(22)],
             want: Ok(value!("local6")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         local7 {
             args: func_args![value: value!(23)],
             want: Ok(value!("local7")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_facility_larger_int {
             args: func_args![value: value!(475)],
             want: Err("facility code 475 not valid"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_facility_negative_int {
             args: func_args![value: value!(-1)],
             want: Err("facility code -1 not valid"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_facility_non_int {
             args: func_args![value: value!("nope")],
-            want: Err(r#"expected "integer", got "string""#),
-            tdef: TypeDef::new().fallible().bytes(),
+            want: Err("expected integer, got string"),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_syslog_level.rs b/lib/vrl/stdlib/src/to_syslog_level.rs
index 2522557fb0805..55a90076fe721 100644
--- a/lib/vrl/stdlib/src/to_syslog_level.rs
+++ b/lib/vrl/stdlib/src/to_syslog_level.rs
@@ -71,7 +71,7 @@ impl Expression for ToSyslogLevelFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().bytes()
+        TypeDef::bytes().fallible()
     }
 }
 
@@ -85,67 +85,67 @@ mod tests {
         emergency {
             args: func_args![value: value!(0)],
             want: Ok(value!("emerg")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         alert {
             args: func_args![value: value!(1)],
             want: Ok(value!("alert")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         critical {
             args: func_args![value: value!(2)],
             want: Ok(value!("crit")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         error {
             args: func_args![value: value!(3)],
             want: Ok(value!("err")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         warning {
             args: func_args![value: value!(4)],
             want: Ok(value!("warning")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         notice {
             args: func_args![value: value!(5)],
             want: Ok(value!("notice")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         informational {
             args: func_args![value: value!(6)],
             want: Ok(value!("info")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         debug {
             args: func_args![value: value!(7)],
             want: Ok(value!("debug")),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_severity_next_int {
             args: func_args![value: value!(8)],
             want: Err("severity level 8 not valid"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_severity_larger_int {
             args: func_args![value: value!(475)],
             want: Err("severity level 475 not valid"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
 
         invalid_severity_negative_int {
             args: func_args![value: value!(-1)],
             want: Err("severity level -1 not valid"),
-            tdef: TypeDef::new().fallible().bytes(),
+            tdef: TypeDef::bytes().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_syslog_severity.rs b/lib/vrl/stdlib/src/to_syslog_severity.rs
index efa55f8fe6cda..e282686d4f767 100644
--- a/lib/vrl/stdlib/src/to_syslog_severity.rs
+++ b/lib/vrl/stdlib/src/to_syslog_severity.rs
@@ -72,7 +72,7 @@ impl Expression for ToSyslogSeverityFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().fallible().integer()
+        TypeDef::integer().fallible()
     }
 }
 
@@ -86,61 +86,61 @@ mod tests {
         emergency {
             args: func_args![value: value!("emerg")],
             want: Ok(value!(0)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         alert {
             args: func_args![value: value!("alert")],
             want: Ok(value!(1)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         critical {
             args: func_args![value: value!("crit")],
             want: Ok(value!(2)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         error {
             args: func_args![value: value!("err")],
             want: Ok(value!(3)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         warning {
             args: func_args![value: value!("warn")],
             want: Ok(value!(4)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         notice {
             args: func_args![value: value!("notice")],
             want: Ok(value!(5)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         informational {
             args: func_args![value: value!("info")],
             want: Ok(value!(6)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         debug {
             args: func_args![value: value!("debug")],
             want: Ok(value!(7)),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         invalid_level_1 {
             args: func_args![value: value!("oopsie")],
             want: Err("syslog level oopsie not valid"),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
 
         invalid_level_2 {
             args: func_args![value: value!("aww schucks")],
             want: Err("syslog level aww schucks not valid"),
-            tdef: TypeDef::new().fallible().integer(),
+            tdef: TypeDef::integer().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_timestamp.rs b/lib/vrl/stdlib/src/to_timestamp.rs
index 4e2431f36e663..100fff03fafb5 100644
--- a/lib/vrl/stdlib/src/to_timestamp.rs
+++ b/lib/vrl/stdlib/src/to_timestamp.rs
@@ -11,7 +11,7 @@ fn to_timestamp(value: Value) -> Resolved {
             let t = Utc.timestamp_opt(v, 0).single();
             match t {
                 Some(time) => time.into(),
-                None => return Err(format!(r#"unable to coerce {} into "timestamp""#, v).into()),
+                None => return Err(format!("unable to coerce {} into timestamp", v).into()),
             }
         }
         Float(v) => {
@@ -23,13 +23,13 @@ fn to_timestamp(value: Value) -> Resolved {
                 .single();
             match t {
                 Some(time) => time.into(),
-                None => return Err(format!(r#"unable to coerce {} into "timestamp""#, v).into()),
+                None => return Err(format!("unable to coerce {} into timestamp", v).into()),
             }
         }
         Bytes(v) => Conversion::Timestamp(TimeZone::Local)
             .convert::<Value>(v)
             .map_err(|err| err.to_string())?,
-        v => return Err(format!(r#"unable to coerce {} into "timestamp""#, v.kind()).into()),
+        v => return Err(format!("unable to coerce {} into timestamp", v.kind()).into()),
     };
     Ok(value)
 }
@@ -59,12 +59,12 @@ impl Function for ToTimestamp {
             },
             Example {
                 title: "integer",
-                source: "to_timestamp(5)",
+                source: "to_timestamp!(5)",
                 result: Ok("t'1970-01-01T00:00:05Z'"),
             },
             Example {
                 title: "float",
-                source: "to_timestamp(5.6)",
+                source: "to_timestamp!(5.6)",
                 result: Ok("t'1970-01-01T00:00:05.600Z'"),
             },
             Example {
@@ -83,42 +83,42 @@ impl Function for ToTimestamp {
                 title: "true",
                 source: "to_timestamp!(true)",
                 result: Err(
-                    r#"function call error for "to_timestamp" at (0:19): unable to coerce "boolean" into "timestamp""#,
+                    r#"function call error for "to_timestamp" at (0:19): unable to coerce boolean into timestamp"#,
                 ),
             },
             Example {
                 title: "false",
                 source: "to_timestamp!(false)",
                 result: Err(
-                    r#"function call error for "to_timestamp" at (0:20): unable to coerce "boolean" into "timestamp""#,
+                    r#"function call error for "to_timestamp" at (0:20): unable to coerce boolean into timestamp"#,
                 ),
             },
             Example {
                 title: "null",
                 source: "to_timestamp!(null)",
                 result: Err(
-                    r#"function call error for "to_timestamp" at (0:19): unable to coerce "null" into "timestamp""#,
+                    r#"function call error for "to_timestamp" at (0:19): unable to coerce null into timestamp"#,
                 ),
             },
             Example {
                 title: "array",
                 source: "to_timestamp!([])",
                 result: Err(
-                    r#"function call error for "to_timestamp" at (0:17): unable to coerce "array" into "timestamp""#,
+                    r#"function call error for "to_timestamp" at (0:17): unable to coerce array into timestamp"#,
                 ),
             },
             Example {
                 title: "object",
                 source: "to_timestamp!({})",
                 result: Err(
-                    r#"function call error for "to_timestamp" at (0:17): unable to coerce "object" into "timestamp""#,
+                    r#"function call error for "to_timestamp" at (0:17): unable to coerce object into timestamp"#,
                 ),
             },
             Example {
                 title: "regex",
                 source: "to_timestamp!(r'foo')",
                 result: Err(
-                    r#"function call error for "to_timestamp" at (0:21): unable to coerce "regex" into "timestamp""#,
+                    r#"function call error for "to_timestamp" at (0:21): unable to coerce regex into timestamp"#,
                 ),
             },
         ]
@@ -154,8 +154,8 @@ impl Expression for ToTimestampFn {
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
         self.value
             .type_def(state)
-            .fallible_unless(Kind::Timestamp | Kind::Integer | Kind::Float)
-            .timestamp()
+            .fallible_unless(Kind::timestamp())
+            .with_kind(Kind::timestamp())
     }
 }
 
@@ -179,7 +179,7 @@ mod tests {
             value: Box::new(Literal::Integer(9999999999999)),
         };
         let string = f.resolve(&mut ctx).err().unwrap().message();
-        assert_eq!(string, r#"unable to coerce 9999999999999 into "timestamp""#)
+        assert_eq!(string, r#"unable to coerce 9999999999999 into timestamp"#)
     }
 
     #[test]
@@ -192,10 +192,7 @@ mod tests {
             value: Box::new(Literal::Float(NotNan::new(9999999999999.9).unwrap())),
         };
         let string = f.resolve(&mut ctx).err().unwrap().message();
-        assert_eq!(
-            string,
-            r#"unable to coerce 9999999999999.9 into "timestamp""#
-        )
+        assert_eq!(string, r#"unable to coerce 9999999999999.9 into timestamp"#)
     }
 
     test_function![
@@ -204,13 +201,13 @@ mod tests {
         integer {
              args: func_args![value: 1431648000],
              want: Ok(chrono::Utc.ymd(2015, 5, 15).and_hms(0, 0, 0)),
-             tdef: TypeDef::new().timestamp(),
+             tdef: TypeDef::timestamp().fallible(),
         }
 
         float {
              args: func_args![value: 1431648000.5],
              want: Ok(chrono::Utc.ymd(2015, 5, 15).and_hms_milli(0, 0, 0, 500)),
-             tdef: TypeDef::new().timestamp(),
+             tdef: TypeDef::timestamp().fallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/to_unix_timestamp.rs b/lib/vrl/stdlib/src/to_unix_timestamp.rs
index c74d92bed321e..a4c8e9bdc369c 100644
--- a/lib/vrl/stdlib/src/to_unix_timestamp.rs
+++ b/lib/vrl/stdlib/src/to_unix_timestamp.rs
@@ -176,7 +176,7 @@ impl Expression for ToUnixTimestampFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().integer()
+        TypeDef::integer().infallible()
     }
 }
 
@@ -194,7 +194,7 @@ mod test {
                              unit: "seconds"
             ],
             want: Ok(1609459200i64),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         milliseconds {
@@ -202,7 +202,7 @@ mod test {
                              unit: "milliseconds"
             ],
             want: Ok(1609459200000i64),
-            tdef: TypeDef::new().infallible().integer(),
+            tdef: TypeDef::integer().infallible(),
         }
 
         nanoseconds {
@@ -210,7 +210,7 @@ mod test {
                               unit: "nanoseconds"
              ],
              want: Ok(1609459200000000000i64),
-             tdef: TypeDef::new().infallible().integer(),
+             tdef: TypeDef::integer().infallible(),
          }
     ];
 }
diff --git a/lib/vrl/stdlib/src/truncate.rs b/lib/vrl/stdlib/src/truncate.rs
index 16d77c2e613b4..2a838ff880395 100644
--- a/lib/vrl/stdlib/src/truncate.rs
+++ b/lib/vrl/stdlib/src/truncate.rs
@@ -104,7 +104,7 @@ impl Expression for TruncateFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -120,7 +120,7 @@ mod tests {
                               limit: 0,
              ],
              want: Ok(""),
-             tdef: TypeDef::new().infallible().bytes(),
+             tdef: TypeDef::bytes().infallible(),
          }
 
         ellipsis {
@@ -129,7 +129,7 @@ mod tests {
                              ellipsis: true
             ],
             want: Ok("..."),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         complete {
@@ -137,7 +137,7 @@ mod tests {
                              limit: 10
             ],
             want: Ok("Super"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         exact {
@@ -146,7 +146,7 @@ mod tests {
                              ellipsis: true
             ],
             want: Ok("Super"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         big {
@@ -154,7 +154,7 @@ mod tests {
                              limit: 5
             ],
             want: Ok("Super"),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         big_ellipsis {
@@ -163,7 +163,7 @@ mod tests {
                              ellipsis: true,
             ],
             want: Ok("Super..."),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
 
         unicode {
@@ -172,7 +172,7 @@ mod tests {
                              ellipsis: true
             ],
             want: Ok("♔♕♖♗♘♙..."),
-            tdef: TypeDef::new().infallible().bytes(),
+            tdef: TypeDef::bytes().infallible(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/unique.rs b/lib/vrl/stdlib/src/unique.rs
index 2da7aff748541..4397e4a917cf9 100644
--- a/lib/vrl/stdlib/src/unique.rs
+++ b/lib/vrl/stdlib/src/unique.rs
@@ -52,7 +52,7 @@ impl Expression for UniqueFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() })
+        TypeDef::array(Collection::any())
     }
 }
 
@@ -68,7 +68,7 @@ mod tests {
                 value: value!(["bar", "foo", "baz", "foo"]),
             ],
             want: Ok(value!(["bar", "foo", "baz"])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
 
         mixed_values {
@@ -76,7 +76,7 @@ mod tests {
                 value: value!(["foo", [1,2,3], "123abc", 1, true, [1,2,3], "foo", true, 1]),
             ],
             want: Ok(value!(["foo", [1,2,3], "123abc", 1, true])),
-            tdef: TypeDef::new().array_mapped::<(), Kind>(map! { (): Kind::all() }),
+            tdef: TypeDef::array(Collection::any()),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/unnest.rs b/lib/vrl/stdlib/src/unnest.rs
index a4268de49efe7..a52eebad98313 100644
--- a/lib/vrl/stdlib/src/unnest.rs
+++ b/lib/vrl/stdlib/src/unnest.rs
@@ -1,5 +1,5 @@
 use lookup_lib::LookupBuf;
-use vrl::prelude::*;
+use vrl::{prelude::*, value::kind::merge};
 
 #[derive(Clone, Copy, Debug)]
 pub struct Unnest;
@@ -94,14 +94,17 @@ impl Expression for UnnestFn {
             }
         };
 
-        let root = target.get(&LookupBuf::root())?.unwrap_or(Value::Null);
+        let root = target
+            .get(&LookupBuf::root())
+            .expect("must never fail")
+            .expect("always a value");
 
         let values = root
             .get_by_path(path)
             .cloned()
             .ok_or(value::Error::Expected {
-                got: Kind::Null,
-                expected: Kind::Array,
+                got: Kind::null(),
+                expected: Kind::array(Collection::any()),
             })?
             .try_array()?;
 
@@ -144,19 +147,59 @@ impl Expression for UnnestFn {
 ///  ]`
 ///
 pub fn invert_array_at_path(typedef: &TypeDef, path: &LookupBuf) -> TypeDef {
-    typedef
-        .at_path(path.clone())
-        .restrict_array()
-        .map_array(|kind| typedef.update_path(path, kind).kind)
+    use value::kind::insert;
+
+    let type_def = typedef.at_path(&path.to_lookup());
+
+    let mut array = Kind::from(type_def)
+        .into_array()
+        .unwrap_or_else(Collection::any);
+
+    array.known_mut().values_mut().for_each(|kind| {
+        let mut tdkind = typedef.kind().clone();
+        tdkind
+            .insert_at_path(
+                &path.to_lookup(),
+                kind.clone(),
+                insert::Strategy {
+                    inner_conflict: insert::InnerConflict::Replace,
+                    leaf_conflict: insert::LeafConflict::Replace,
+                    coalesced_path: insert::CoalescedPath::InsertAll,
+                },
+            )
+            .expect("infallible");
+
+        *kind = tdkind.clone();
+    });
+
+    let mut tdkind = typedef.kind().clone();
+
+    let unknown = array.unknown().map(|unknown| {
+        tdkind
+            .insert_at_path(
+                &path.to_lookup(),
+                unknown.clone().into(),
+                insert::Strategy {
+                    inner_conflict: insert::InnerConflict::Merge(merge::Strategy {
+                        depth: merge::Depth::Deep,
+                        indices: merge::Indices::Keep,
+                    }),
+                    leaf_conflict: insert::LeafConflict::Replace,
+                    coalesced_path: insert::CoalescedPath::InsertAll,
+                },
+            )
+            .expect("infallible");
+        tdkind
+    });
+
+    array.set_unknown(unknown);
+
+    TypeDef::array(array)
 }
 
 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeSet;
-
-    use type_def::KindInfo;
     use vector_common::{btreemap, TimeZone};
-    use vrl::Index;
 
     use super::*;
 
@@ -263,16 +306,15 @@ mod tests {
                 new: type_def! { array [
                     type_def! { object {
                         "nonk" => type_def! { array {
-                            (Index::Any) => type_def! { object {
+                            unknown => type_def! { object {
                                 "noog" => type_def! { array [
                                     type_def! { bytes },
                                 ] },
                                 "nork" => type_def! { bytes },
                             } },
-                            // The index is added on top of the Any entry.
-                            (Index::Index(0)) => type_def! { object {
+                            // The index is added on top of the "unknown" entry.
+                            0 => type_def! { object {
                                 "noog" => type_def! { bytes },
-                                "nork" => type_def! { bytes },
                             } },
                         } },
                     } },
@@ -282,7 +324,7 @@ mod tests {
             TestCase {
                 old: type_def! { object {
                     "nonk" => type_def! { array {
-                        Index::Index(0) => type_def! { object {
+                        0 => type_def! { object {
                             "noog" => type_def! { array [
                                 type_def! { bytes },
                             ] },
@@ -295,7 +337,7 @@ mod tests {
                     type_def! { object {
                         "nonk" => type_def! { array {
                             // The index is added on top of the Any entry.
-                            (Index::Index(0)) => type_def! { object {
+                            0 => type_def! { object {
                                 "noog" => type_def! { bytes },
                                 "nork" => type_def! { bytes },
                             } },
@@ -327,9 +369,45 @@ mod tests {
                     } },
                 ] },
             },
-            // Coalesce
+            //// Coalesce with known path first
+            ////
+            //// FIXME(Jean): There's still a bug in the `InsertValid` implementation that prevents
+            //// this from working as expected.
+            ////
+            //// I'm assuming it has something to do with us _inserting_ the coalesced field, and
+            //// _then_ checking if a certain field in the list of coalesced fields can be null at
+            //// runtime. Instead, we should check so _before_ inserting the field.
+            ////
+            //// This is existing behavior though, and it's not "breaking" anything, in that the
+            //// resulting type definition is more expansive than it needs to be, requiring operators
+            //// to add more type coercing, but it'd be nice to fix this at some point.
+            //TestCase {
+            //    old: type_def! { object {
+            //        "nonk" => type_def! { object {
+            //            "shnoog" => type_def! { array [
+            //                type_def! { object {
+            //                    "noog" => type_def! { bytes },
+            //                    "nork" => type_def! { bytes },
+            //                } },
+            //            ] },
+            //        } },
+            //    } },
+            //    path: ".(nonk | nork).shnoog",
+            //    new: type_def! { array [
+            //        type_def! { object {
+            //            "nonk" => type_def! { object {
+            //                "shnoog" => type_def! { object {
+            //                    "noog" => type_def! { bytes },
+            //                    "nork" => type_def! { bytes },
+            //                } },
+            //            } },
+            //        } },
+            //    ] },
+            //},
+            // Coalesce with known path second
             TestCase {
                 old: type_def! { object {
+                    unknown => type_def! { bytes },
                     "nonk" => type_def! { object {
                         "shnoog" => type_def! { array [
                             type_def! { object {
@@ -339,15 +417,22 @@ mod tests {
                         ] },
                     } },
                 } },
-                path: ".(nonk | nork).shnoog",
+                path: ".(nork | nonk).shnoog",
                 new: type_def! { array [
                     type_def! { object {
+                        unknown => type_def! { bytes },
                         "nonk" => type_def! { object {
                             "shnoog" => type_def! { object {
                                 "noog" => type_def! { bytes },
                                 "nork" => type_def! { bytes },
                             } },
-                        } }.add_null(),
+                        } },
+                        "nork" => type_def! { object {
+                            "shnoog" => type_def! { object {
+                                "noog" => type_def! { bytes },
+                                "nork" => type_def! { bytes },
+                            } },
+                        } },
                     } },
                 ] },
             },
@@ -360,6 +445,7 @@ mod tests {
                 new: type_def! { array [
                     type_def! { object {
                         "nonk" => type_def! { bytes },
+                        "norg" => type_def! { unknown },
                     } },
                 ] },
             },
@@ -368,6 +454,7 @@ mod tests {
         for case in cases {
             let path = LookupBuf::from_str(case.path).unwrap();
             let new = invert_array_at_path(&case.old, &path);
+
             assert_eq!(case.new, new, "{}", path);
         }
     }
@@ -392,11 +479,12 @@ mod tests {
             ),
             (
                 value!({"hostname": "localhost", "events": [{"message": "hello"}, {"message": "world"}]}),
-                Err(r#"expected "array", got "null""#.to_owned()),
+                Err("expected array, got null".to_owned()),
                 UnnestFn::new("unknown"),
                 type_def! { array [
                     type_def! { object {
                         "hostname" => type_def! { bytes },
+                        "unknown" => type_def! { unknown },
                         "events" => type_def! { array [
                             type_def! { object {
                                 "message" => type_def! { bytes },
@@ -407,27 +495,27 @@ mod tests {
             ),
             (
                 value!({"hostname": "localhost", "events": [{"message": "hello"}, {"message": "world"}]}),
-                Err(r#"expected "array", got "string""#.to_owned()),
+                Err("expected array, got string".to_owned()),
                 UnnestFn::new("hostname"),
-                // The typedef in this case is not particularly important as we will have a compile
-                // error before we get to this point.
-                TypeDef {
-                    fallible: false,
-                    kind: KindInfo::Known(BTreeSet::new()),
-                },
+                type_def! { array [
+                    type_def! { object {
+                        "hostname" => type_def! { unknown },
+                        "events" => type_def! { array [
+                            type_def! { object {
+                                "message" => type_def! { bytes },
+                            } },
+                        ] },
+                    } },
+                ] },
             ),
         ];
 
-        let compiler = state::Compiler::new_with_type_def(
-            TypeDef::new().object::<&'static str, TypeDef>(btreemap! {
-                "hostname" => TypeDef::new().bytes(),
-                "events" => TypeDef::new().array_mapped::<(), TypeDef>(btreemap! {
-                        () => TypeDef::new().object::<&'static str, TypeDef>(btreemap! {
-                            "message" => TypeDef::new().bytes()
-                        })
-                }),
-            }),
-        );
+        let compiler = state::Compiler::new_with_type_def(TypeDef::object(btreemap! {
+            "hostname" => Kind::bytes(),
+            "events" => Kind::array(Collection::from_unknown(Kind::object(btreemap! {
+                Field::from("message") => Kind::bytes(),
+            })),
+        )}));
 
         let tz = TimeZone::default();
         for (object, expected, func, expected_typedef) in cases {
@@ -435,14 +523,14 @@ mod tests {
             let mut runtime_state = vrl::state::Runtime::default();
             let mut ctx = Context::new(&mut object, &mut runtime_state, &tz);
 
-            let typedef = func.type_def(&compiler);
+            let got_typedef = func.type_def(&compiler);
 
             let got = func
                 .resolve(&mut ctx)
                 .map_err(|e| format!("{:#}", anyhow::anyhow!(e)));
 
             assert_eq!(got, expected);
-            assert_eq!(typedef, expected_typedef);
+            assert_eq!(got_typedef, expected_typedef);
         }
     }
 }
diff --git a/lib/vrl/stdlib/src/upcase.rs b/lib/vrl/stdlib/src/upcase.rs
index 9f2a8e83cd2fb..1cbca3fa5ce94 100644
--- a/lib/vrl/stdlib/src/upcase.rs
+++ b/lib/vrl/stdlib/src/upcase.rs
@@ -57,7 +57,7 @@ impl Expression for UpcaseFn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -71,7 +71,7 @@ mod tests {
         simple {
             args: func_args![value: "FOO 2 bar"],
             want: Ok(value!("FOO 2 BAR")),
-            tdef: TypeDef::new().bytes(),
+            tdef: TypeDef::bytes(),
         }
     ];
 }
diff --git a/lib/vrl/stdlib/src/util.rs b/lib/vrl/stdlib/src/util.rs
index c44bc23b4266f..3cc8756d92bea 100644
--- a/lib/vrl/stdlib/src/util.rs
+++ b/lib/vrl/stdlib/src/util.rs
@@ -45,22 +45,22 @@ pub(crate) fn capture_regex_to_map(
 }
 
 #[cfg(any(feature = "parse_regex", feature = "parse_regex_all"))]
-pub(crate) fn regex_type_def(
+pub(crate) fn regex_kind(
     regex: &regex::Regex,
-) -> std::collections::BTreeMap<String, vrl::value::Kind> {
+) -> std::collections::BTreeMap<vrl::value::kind::Field, vrl::value::Kind> {
     let mut inner_type = std::collections::BTreeMap::new();
 
     // Add typedefs for each capture by numerical index.
     for num in 0..regex.captures_len() {
         inner_type.insert(
-            num.to_string(),
-            vrl::value::Kind::Bytes | vrl::value::Kind::Null,
+            num.to_string().into(),
+            vrl::value::Kind::bytes() | vrl::value::Kind::null(),
         );
     }
 
     // Add a typedef for each capture name.
     for name in regex.capture_names().flatten() {
-        inner_type.insert(name.to_owned(), vrl::value::Kind::Bytes);
+        inner_type.insert(name.to_owned().into(), vrl::value::Kind::bytes());
     }
 
     inner_type
diff --git a/lib/vrl/stdlib/src/uuid_v4.rs b/lib/vrl/stdlib/src/uuid_v4.rs
index c3fb5623c63cb..4e84019a7b59f 100644
--- a/lib/vrl/stdlib/src/uuid_v4.rs
+++ b/lib/vrl/stdlib/src/uuid_v4.rs
@@ -39,7 +39,7 @@ impl Expression for UuidV4Fn {
     }
 
     fn type_def(&self, _: &state::Compiler) -> TypeDef {
-        TypeDef::new().infallible().bytes()
+        TypeDef::bytes().infallible()
     }
 }
 
@@ -51,7 +51,7 @@ mod tests {
 
     test_type_def![default {
         expr: |_| { UuidV4Fn },
-        want: TypeDef::new().infallible().bytes(),
+        want: TypeDef::bytes().infallible(),
     }];
 
     #[test]
diff --git a/lib/vrl/tests/tests/diagnostics/abort_with_non_string_message.vrl b/lib/vrl/tests/tests/diagnostics/abort_with_non_string_message.vrl
index 7f853141e63d3..9b3360eb7a39e 100644
--- a/lib/vrl/tests/tests/diagnostics/abort_with_non_string_message.vrl
+++ b/lib/vrl/tests/tests/diagnostics/abort_with_non_string_message.vrl
@@ -7,7 +7,7 @@
 #   │       ^
 #   │       │
 #   │       abort only accepts an expression argument resolving to a string
-#   │       this expression resolves to "object"
+#   │       this expression resolves to object
 #   │
 #   = hint: coerce the value to the required type using a coercion function
 #   = see documentation about type coercion at https://functions.vrl.dev/#coerce-functions
diff --git a/lib/vrl/tests/tests/diagnostics/invalid_if_condition_type.vrl b/lib/vrl/tests/tests/diagnostics/invalid_if_condition_type.vrl
index 3d387eda2e972..28a0fbe31f0a2 100644
--- a/lib/vrl/tests/tests/diagnostics/invalid_if_condition_type.vrl
+++ b/lib/vrl/tests/tests/diagnostics/invalid_if_condition_type.vrl
@@ -7,7 +7,7 @@
 #   │    ^^^^^^
 #   │    │
 #   │    this predicate must resolve to a boolean
-#   │    instead it resolves to "string"
+#   │    instead it resolves to string
 #   │
 #   = hint: coerce the value to the required type using a coercion function
 #   = see documentation about if expressions at https://vrl.dev/expressions/#if
diff --git a/lib/vrl/tests/tests/diagnostics/invalid_unary_not_type.vrl b/lib/vrl/tests/tests/diagnostics/invalid_unary_not_type.vrl
index 76b0c02605bfb..43feb8045dd43 100644
--- a/lib/vrl/tests/tests/diagnostics/invalid_unary_not_type.vrl
+++ b/lib/vrl/tests/tests/diagnostics/invalid_unary_not_type.vrl
@@ -4,7 +4,7 @@
 #   ┌─ :2:2
 #   │
 # 2 │ !!"true"
-#   │  ^------ this expression resolves to "string"
+#   │  ^------ this expression resolves to string
 #   │  │
 #   │  negation only works on boolean values
 #   │
diff --git a/lib/vrl/tests/tests/diagnostics/program_aborted_invalid_argument_type.vrl b/lib/vrl/tests/tests/diagnostics/program_aborted_invalid_argument_type.vrl
index 3af2ea2e90d97..dff3f34102605 100644
--- a/lib/vrl/tests/tests/diagnostics/program_aborted_invalid_argument_type.vrl
+++ b/lib/vrl/tests/tests/diagnostics/program_aborted_invalid_argument_type.vrl
@@ -1,5 +1,5 @@
 # result:
 #
-# function call error for "to_string" at (1:15): unable to coerce "array" into "string"
+# function call error for "to_string" at (1:15): unable to coerce array into string
 
 to_string!([])
diff --git a/lib/vrl/tests/tests/diagnostics/unhandled_parse_regex_all_type.vrl b/lib/vrl/tests/tests/diagnostics/unhandled_parse_regex_all_type.vrl
index 50120eefa5fc7..f00eb3f8b8c85 100644
--- a/lib/vrl/tests/tests/diagnostics/unhandled_parse_regex_all_type.vrl
+++ b/lib/vrl/tests/tests/diagnostics/unhandled_parse_regex_all_type.vrl
@@ -19,4 +19,5 @@
 .result = parse_regex_all!(.message, r'(?P<an>an.)')
 .a = sha3(.result[0].an)
 
+.result
 "can't work since all array access is error prone"
diff --git a/lib/vrl/tests/tests/expressions/arithmetic/addition/invalid.vrl b/lib/vrl/tests/tests/expressions/arithmetic/addition/invalid.vrl
index 24cafe4deb6fe..64871a5b001b7 100644
--- a/lib/vrl/tests/tests/expressions/arithmetic/addition/invalid.vrl
+++ b/lib/vrl/tests/tests/expressions/arithmetic/addition/invalid.vrl
@@ -1,95 +1,95 @@
 # result: [
-#     "can't add type \"string\" to \"integer\"",
-#     "can't add type \"boolean\" to \"integer\"",
-#     "can't add type \"boolean\" to \"integer\"",
-#     "can't add type \"null\" to \"integer\"",
-#     "can't add type \"array\" to \"integer\"",
-#     "can't add type \"object\" to \"integer\"",
-#     "can't add type \"regex\" to \"integer\"",
-#     "can't add type \"timestamp\" to \"integer\"",
+#     "can't add type string to integer",
+#     "can't add type boolean to integer",
+#     "can't add type boolean to integer",
+#     "can't add type null to integer",
+#     "can't add type array to integer",
+#     "can't add type object to integer",
+#     "can't add type regex to integer",
+#     "can't add type timestamp to integer",
 #
-#     "can't add type \"string\" to \"float\"",
-#     "can't add type \"boolean\" to \"float\"",
-#     "can't add type \"boolean\" to \"float\"",
-#     "can't add type \"null\" to \"float\"",
-#     "can't add type \"array\" to \"float\"",
-#     "can't add type \"object\" to \"float\"",
-#     "can't add type \"regex\" to \"float\"",
-#     "can't add type \"timestamp\" to \"float\"",
+#     "can't add type string to float",
+#     "can't add type boolean to float",
+#     "can't add type boolean to float",
+#     "can't add type null to float",
+#     "can't add type array to float",
+#     "can't add type object to float",
+#     "can't add type regex to float",
+#     "can't add type timestamp to float",
 #
-#     "can't add type \"integer\" to \"string\"",
-#     "can't add type \"float\" to \"string\"",
-#     "can't add type \"boolean\" to \"string\"",
-#     "can't add type \"boolean\" to \"string\"",
-#     "can't add type \"array\" to \"string\"",
-#     "can't add type \"object\" to \"string\"",
-#     "can't add type \"regex\" to \"string\"",
-#     "can't add type \"timestamp\" to \"string\"",
+#     "can't add type integer to string",
+#     "can't add type float to string",
+#     "can't add type boolean to string",
+#     "can't add type boolean to string",
+#     "can't add type array to string",
+#     "can't add type object to string",
+#     "can't add type regex to string",
+#     "can't add type timestamp to string",
 #
-#     "can't add type \"integer\" to \"boolean\"",
-#     "can't add type \"float\" to \"boolean\"",
-#     "can't add type \"string\" to \"boolean\"",
-#     "can't add type \"boolean\" to \"boolean\"",
-#     "can't add type \"boolean\" to \"boolean\"",
-#     "can't add type \"null\" to \"boolean\"",
-#     "can't add type \"array\" to \"boolean\"",
-#     "can't add type \"object\" to \"boolean\"",
-#     "can't add type \"regex\" to \"boolean\"",
-#     "can't add type \"timestamp\" to \"boolean\"",
+#     "can't add type integer to boolean",
+#     "can't add type float to boolean",
+#     "can't add type string to boolean",
+#     "can't add type boolean to boolean",
+#     "can't add type boolean to boolean",
+#     "can't add type null to boolean",
+#     "can't add type array to boolean",
+#     "can't add type object to boolean",
+#     "can't add type regex to boolean",
+#     "can't add type timestamp to boolean",
 #
-#     "can't add type \"integer\" to \"null\"",
-#     "can't add type \"float\" to \"null\"",
-#     "can't add type \"boolean\" to \"null\"",
-#     "can't add type \"boolean\" to \"null\"",
-#     "can't add type \"null\" to \"null\"",
-#     "can't add type \"array\" to \"null\"",
-#     "can't add type \"object\" to \"null\"",
-#     "can't add type \"regex\" to \"null\"",
-#     "can't add type \"timestamp\" to \"null\"",
+#     "can't add type integer to null",
+#     "can't add type float to null",
+#     "can't add type boolean to null",
+#     "can't add type boolean to null",
+#     "can't add type null to null",
+#     "can't add type array to null",
+#     "can't add type object to null",
+#     "can't add type regex to null",
+#     "can't add type timestamp to null",
 #
-#     "can't add type \"string\" to \"array\"",
-#     "can't add type \"integer\" to \"array\"",
-#     "can't add type \"float\" to \"array\"",
-#     "can't add type \"boolean\" to \"array\"",
-#     "can't add type \"boolean\" to \"array\"",
-#     "can't add type \"null\" to \"array\"",
-#     "can't add type \"array\" to \"array\"",
-#     "can't add type \"object\" to \"array\"",
-#     "can't add type \"regex\" to \"array\"",
-#     "can't add type \"timestamp\" to \"array\"",
+#     "can't add type string to array",
+#     "can't add type integer to array",
+#     "can't add type float to array",
+#     "can't add type boolean to array",
+#     "can't add type boolean to array",
+#     "can't add type null to array",
+#     "can't add type array to array",
+#     "can't add type object to array",
+#     "can't add type regex to array",
+#     "can't add type timestamp to array",
 #
-#     "can't add type \"string\" to \"object\"",
-#     "can't add type \"integer\" to \"object\"",
-#     "can't add type \"float\" to \"object\"",
-#     "can't add type \"boolean\" to \"object\"",
-#     "can't add type \"boolean\" to \"object\"",
-#     "can't add type \"null\" to \"object\"",
-#     "can't add type \"array\" to \"object\"",
-#     "can't add type \"object\" to \"object\"",
-#     "can't add type \"regex\" to \"object\"",
-#     "can't add type \"timestamp\" to \"object\"",
+#     "can't add type string to object",
+#     "can't add type integer to object",
+#     "can't add type float to object",
+#     "can't add type boolean to object",
+#     "can't add type boolean to object",
+#     "can't add type null to object",
+#     "can't add type array to object",
+#     "can't add type object to object",
+#     "can't add type regex to object",
+#     "can't add type timestamp to object",
 #
-#     "can't add type \"string\" to \"regex\"",
-#     "can't add type \"integer\" to \"regex\"",
-#     "can't add type \"float\" to \"regex\"",
-#     "can't add type \"boolean\" to \"regex\"",
-#     "can't add type \"boolean\" to \"regex\"",
-#     "can't add type \"null\" to \"regex\"",
-#     "can't add type \"array\" to \"regex\"",
-#     "can't add type \"object\" to \"regex\"",
-#     "can't add type \"regex\" to \"regex\"",
-#     "can't add type \"timestamp\" to \"regex\"",
+#     "can't add type string to regex",
+#     "can't add type integer to regex",
+#     "can't add type float to regex",
+#     "can't add type boolean to regex",
+#     "can't add type boolean to regex",
+#     "can't add type null to regex",
+#     "can't add type array to regex",
+#     "can't add type object to regex",
+#     "can't add type regex to regex",
+#     "can't add type timestamp to regex",
 #
-#     "can't add type \"string\" to \"timestamp\"",
-#     "can't add type \"integer\" to \"timestamp\"",
-#     "can't add type \"float\" to \"timestamp\"",
-#     "can't add type \"boolean\" to \"timestamp\"",
-#     "can't add type \"boolean\" to \"timestamp\"",
-#     "can't add type \"null\" to \"timestamp\"",
-#     "can't add type \"array\" to \"timestamp\"",
-#     "can't add type \"object\" to \"timestamp\"",
-#     "can't add type \"regex\" to \"timestamp\"",
-#     "can't add type \"timestamp\" to \"timestamp\""
+#     "can't add type string to timestamp",
+#     "can't add type integer to timestamp",
+#     "can't add type float to timestamp",
+#     "can't add type boolean to timestamp",
+#     "can't add type boolean to timestamp",
+#     "can't add type null to timestamp",
+#     "can't add type array to timestamp",
+#     "can't add type object to timestamp",
+#     "can't add type regex to timestamp",
+#     "can't add type timestamp to timestamp"
 # ]
 
 ok, err1 = 1 + "foo"
diff --git a/lib/vrl/tests/tests/expressions/arithmetic/division/invalid.vrl b/lib/vrl/tests/tests/expressions/arithmetic/division/invalid.vrl
index 34cdda7b989e1..c350bc3681bb4 100644
--- a/lib/vrl/tests/tests/expressions/arithmetic/division/invalid.vrl
+++ b/lib/vrl/tests/tests/expressions/arithmetic/division/invalid.vrl
@@ -1,96 +1,96 @@
 # result: [
-#     "can't divide type \"integer\" by \"boolean\"",
-#     "can't divide type \"integer\" by \"boolean\"",
-#     "can't divide type \"integer\" by \"null\"",
-#     "can't divide type \"integer\" by \"array\"",
-#     "can't divide type \"integer\" by \"object\"",
-#     "can't divide type \"integer\" by \"regex\"",
-#     "can't divide type \"integer\" by \"timestamp\"",
+#     "can't divide type integer by boolean",
+#     "can't divide type integer by boolean",
+#     "can't divide type integer by null",
+#     "can't divide type integer by array",
+#     "can't divide type integer by object",
+#     "can't divide type integer by regex",
+#     "can't divide type integer by timestamp",
 #
-#     "can't divide type \"float\" by \"string\"",
-#     "can't divide type \"float\" by \"boolean\"",
-#     "can't divide type \"float\" by \"boolean\"",
-#     "can't divide type \"float\" by \"null\"",
-#     "can't divide type \"float\" by \"array\"",
-#     "can't divide type \"float\" by \"object\"",
-#     "can't divide type \"float\" by \"regex\"",
-#     "can't divide type \"float\" by \"timestamp\"",
+#     "can't divide type float by string",
+#     "can't divide type float by boolean",
+#     "can't divide type float by boolean",
+#     "can't divide type float by null",
+#     "can't divide type float by array",
+#     "can't divide type float by object",
+#     "can't divide type float by regex",
+#     "can't divide type float by timestamp",
 #
-#     "can't divide type \"string\" by \"string\"",
-#     "can't divide type \"string\" by \"float\"",
-#     "can't divide type \"string\" by \"boolean\"",
-#     "can't divide type \"string\" by \"boolean\"",
-#     "can't divide type \"string\" by \"null\"",
-#     "can't divide type \"string\" by \"array\"",
-#     "can't divide type \"string\" by \"object\"",
-#     "can't divide type \"string\" by \"regex\"",
-#     "can't divide type \"string\" by \"timestamp\"",
+#     "can't divide type string by string",
+#     "can't divide type string by float",
+#     "can't divide type string by boolean",
+#     "can't divide type string by boolean",
+#     "can't divide type string by null",
+#     "can't divide type string by array",
+#     "can't divide type string by object",
+#     "can't divide type string by regex",
+#     "can't divide type string by timestamp",
 #
-#     "can't divide type \"boolean\" by \"string\"",
-#     "can't divide type \"boolean\" by \"integer\"",
-#     "can't divide type \"boolean\" by \"float\"",
-#     "can't divide type \"boolean\" by \"boolean\"",
-#     "can't divide type \"boolean\" by \"boolean\"",
-#     "can't divide type \"boolean\" by \"null\"",
-#     "can't divide type \"boolean\" by \"array\"",
-#     "can't divide type \"boolean\" by \"object\"",
-#     "can't divide type \"boolean\" by \"regex\"",
-#     "can't divide type \"boolean\" by \"timestamp\"",
+#     "can't divide type boolean by string",
+#     "can't divide type boolean by integer",
+#     "can't divide type boolean by float",
+#     "can't divide type boolean by boolean",
+#     "can't divide type boolean by boolean",
+#     "can't divide type boolean by null",
+#     "can't divide type boolean by array",
+#     "can't divide type boolean by object",
+#     "can't divide type boolean by regex",
+#     "can't divide type boolean by timestamp",
 #
-#     "can't divide type \"null\" by \"string\"",
-#     "can't divide type \"null\" by \"integer\"",
-#     "can't divide type \"null\" by \"float\"",
-#     "can't divide type \"null\" by \"boolean\"",
-#     "can't divide type \"null\" by \"boolean\"",
-#     "can't divide type \"null\" by \"null\"",
-#     "can't divide type \"null\" by \"array\"",
-#     "can't divide type \"null\" by \"object\"",
-#     "can't divide type \"null\" by \"regex\"",
-#     "can't divide type \"null\" by \"timestamp\"",
+#     "can't divide type null by string",
+#     "can't divide type null by integer",
+#     "can't divide type null by float",
+#     "can't divide type null by boolean",
+#     "can't divide type null by boolean",
+#     "can't divide type null by null",
+#     "can't divide type null by array",
+#     "can't divide type null by object",
+#     "can't divide type null by regex",
+#     "can't divide type null by timestamp",
 #
-#     "can't divide type \"array\" by \"string\"",
-#     "can't divide type \"array\" by \"integer\"",
-#     "can't divide type \"array\" by \"float\"",
-#     "can't divide type \"array\" by \"boolean\"",
-#     "can't divide type \"array\" by \"boolean\"",
-#     "can't divide type \"array\" by \"null\"",
-#     "can't divide type \"array\" by \"array\"",
-#     "can't divide type \"array\" by \"object\"",
-#     "can't divide type \"array\" by \"regex\"",
-#     "can't divide type \"array\" by \"timestamp\"",
+#     "can't divide type array by string",
+#     "can't divide type array by integer",
+#     "can't divide type array by float",
+#     "can't divide type array by boolean",
+#     "can't divide type array by boolean",
+#     "can't divide type array by null",
+#     "can't divide type array by array",
+#     "can't divide type array by object",
+#     "can't divide type array by regex",
+#     "can't divide type array by timestamp",
 #
-#     "can't divide type \"object\" by \"string\"",
-#     "can't divide type \"object\" by \"integer\"",
-#     "can't divide type \"object\" by \"float\"",
-#     "can't divide type \"object\" by \"boolean\"",
-#     "can't divide type \"object\" by \"boolean\"",
-#     "can't divide type \"object\" by \"null\"",
-#     "can't divide type \"object\" by \"array\"",
-#     "can't divide type \"object\" by \"object\"",
-#     "can't divide type \"object\" by \"regex\"",
-#     "can't divide type \"object\" by \"timestamp\"",
+#     "can't divide type object by string",
+#     "can't divide type object by integer",
+#     "can't divide type object by float",
+#     "can't divide type object by boolean",
+#     "can't divide type object by boolean",
+#     "can't divide type object by null",
+#     "can't divide type object by array",
+#     "can't divide type object by object",
+#     "can't divide type object by regex",
+#     "can't divide type object by timestamp",
 #
-#     "can't divide type \"regex\" by \"string\"",
-#     "can't divide type \"regex\" by \"integer\"",
-#     "can't divide type \"regex\" by \"float\"",
-#     "can't divide type \"regex\" by \"boolean\"",
-#     "can't divide type \"regex\" by \"boolean\"",
-#     "can't divide type \"regex\" by \"null\"",
-#     "can't divide type \"regex\" by \"array\"",
-#     "can't divide type \"regex\" by \"object\"",
-#     "can't divide type \"regex\" by \"regex\"",
-#     "can't divide type \"regex\" by \"timestamp\"",
+#     "can't divide type regex by string",
+#     "can't divide type regex by integer",
+#     "can't divide type regex by float",
+#     "can't divide type regex by boolean",
+#     "can't divide type regex by boolean",
+#     "can't divide type regex by null",
+#     "can't divide type regex by array",
+#     "can't divide type regex by object",
+#     "can't divide type regex by regex",
+#     "can't divide type regex by timestamp",
 #
-#     "can't divide type \"timestamp\" by \"string\"",
-#     "can't divide type \"timestamp\" by \"integer\"",
-#     "can't divide type \"timestamp\" by \"float\"",
-#     "can't divide type \"timestamp\" by \"boolean\"",
-#     "can't divide type \"timestamp\" by \"boolean\"",
-#     "can't divide type \"timestamp\" by \"null\"",
-#     "can't divide type \"timestamp\" by \"array\"",
-#     "can't divide type \"timestamp\" by \"object\"",
-#     "can't divide type \"timestamp\" by \"regex\"",
-#     "can't divide type \"timestamp\" by \"timestamp\""
+#     "can't divide type timestamp by string",
+#     "can't divide type timestamp by integer",
+#     "can't divide type timestamp by float",
+#     "can't divide type timestamp by boolean",
+#     "can't divide type timestamp by boolean",
+#     "can't divide type timestamp by null",
+#     "can't divide type timestamp by array",
+#     "can't divide type timestamp by object",
+#     "can't divide type timestamp by regex",
+#     "can't divide type timestamp by timestamp"
 # ]
 
 ok, err1 = 1 / true
diff --git a/lib/vrl/tests/tests/expressions/arithmetic/multiplication/invalid.vrl b/lib/vrl/tests/tests/expressions/arithmetic/multiplication/invalid.vrl
index 6b5f2f052d9c6..bc6c30db20ad8 100644
--- a/lib/vrl/tests/tests/expressions/arithmetic/multiplication/invalid.vrl
+++ b/lib/vrl/tests/tests/expressions/arithmetic/multiplication/invalid.vrl
@@ -1,96 +1,96 @@
 # result: [
-#     "can't multiply type \"integer\" by \"boolean\"",
-#     "can't multiply type \"integer\" by \"boolean\"",
-#     "can't multiply type \"integer\" by \"null\"",
-#     "can't multiply type \"integer\" by \"array\"",
-#     "can't multiply type \"integer\" by \"object\"",
-#     "can't multiply type \"integer\" by \"regex\"",
-#     "can't multiply type \"integer\" by \"timestamp\"",
+#     "can't multiply type integer by boolean",
+#     "can't multiply type integer by boolean",
+#     "can't multiply type integer by null",
+#     "can't multiply type integer by array",
+#     "can't multiply type integer by object",
+#     "can't multiply type integer by regex",
+#     "can't multiply type integer by timestamp",
 #
-#     "can't multiply type \"float\" by \"string\"",
-#     "can't multiply type \"float\" by \"boolean\"",
-#     "can't multiply type \"float\" by \"boolean\"",
-#     "can't multiply type \"float\" by \"null\"",
-#     "can't multiply type \"float\" by \"array\"",
-#     "can't multiply type \"float\" by \"object\"",
-#     "can't multiply type \"float\" by \"regex\"",
-#     "can't multiply type \"float\" by \"timestamp\"",
+#     "can't multiply type float by string",
+#     "can't multiply type float by boolean",
+#     "can't multiply type float by boolean",
+#     "can't multiply type float by null",
+#     "can't multiply type float by array",
+#     "can't multiply type float by object",
+#     "can't multiply type float by regex",
+#     "can't multiply type float by timestamp",
 #
-#     "can't multiply type \"string\" by \"string\"",
-#     "can't multiply type \"string\" by \"float\"",
-#     "can't multiply type \"string\" by \"boolean\"",
-#     "can't multiply type \"string\" by \"boolean\"",
-#     "can't multiply type \"string\" by \"null\"",
-#     "can't multiply type \"string\" by \"array\"",
-#     "can't multiply type \"string\" by \"object\"",
-#     "can't multiply type \"string\" by \"regex\"",
-#     "can't multiply type \"string\" by \"timestamp\"",
+#     "can't multiply type string by string",
+#     "can't multiply type string by float",
+#     "can't multiply type string by boolean",
+#     "can't multiply type string by boolean",
+#     "can't multiply type string by null",
+#     "can't multiply type string by array",
+#     "can't multiply type string by object",
+#     "can't multiply type string by regex",
+#     "can't multiply type string by timestamp",
 #
-#     "can't multiply type \"boolean\" by \"string\"",
-#     "can't multiply type \"boolean\" by \"integer\"",
-#     "can't multiply type \"boolean\" by \"float\"",
-#     "can't multiply type \"boolean\" by \"boolean\"",
-#     "can't multiply type \"boolean\" by \"boolean\"",
-#     "can't multiply type \"boolean\" by \"null\"",
-#     "can't multiply type \"boolean\" by \"array\"",
-#     "can't multiply type \"boolean\" by \"object\"",
-#     "can't multiply type \"boolean\" by \"regex\"",
-#     "can't multiply type \"boolean\" by \"timestamp\"",
+#     "can't multiply type boolean by string",
+#     "can't multiply type boolean by integer",
+#     "can't multiply type boolean by float",
+#     "can't multiply type boolean by boolean",
+#     "can't multiply type boolean by boolean",
+#     "can't multiply type boolean by null",
+#     "can't multiply type boolean by array",
+#     "can't multiply type boolean by object",
+#     "can't multiply type boolean by regex",
+#     "can't multiply type boolean by timestamp",
 #
-#     "can't multiply type \"null\" by \"string\"",
-#     "can't multiply type \"null\" by \"integer\"",
-#     "can't multiply type \"null\" by \"float\"",
-#     "can't multiply type \"null\" by \"boolean\"",
-#     "can't multiply type \"null\" by \"boolean\"",
-#     "can't multiply type \"null\" by \"null\"",
-#     "can't multiply type \"null\" by \"array\"",
-#     "can't multiply type \"null\" by \"object\"",
-#     "can't multiply type \"null\" by \"regex\"",
-#     "can't multiply type \"null\" by \"timestamp\"",
+#     "can't multiply type null by string",
+#     "can't multiply type null by integer",
+#     "can't multiply type null by float",
+#     "can't multiply type null by boolean",
+#     "can't multiply type null by boolean",
+#     "can't multiply type null by null",
+#     "can't multiply type null by array",
+#     "can't multiply type null by object",
+#     "can't multiply type null by regex",
+#     "can't multiply type null by timestamp",
 #
-#     "can't multiply type \"array\" by \"string\"",
-#     "can't multiply type \"array\" by \"integer\"",
-#     "can't multiply type \"array\" by \"float\"",
-#     "can't multiply type \"array\" by \"boolean\"",
-#     "can't multiply type \"array\" by \"boolean\"",
-#     "can't multiply type \"array\" by \"null\"",
-#     "can't multiply type \"array\" by \"array\"",
-#     "can't multiply type \"array\" by \"object\"",
-#     "can't multiply type \"array\" by \"regex\"",
-#     "can't multiply type \"array\" by \"timestamp\"",
+#     "can't multiply type array by string",
+#     "can't multiply type array by integer",
+#     "can't multiply type array by float",
+#     "can't multiply type array by boolean",
+#     "can't multiply type array by boolean",
+#     "can't multiply type array by null",
+#     "can't multiply type array by array",
+#     "can't multiply type array by object",
+#     "can't multiply type array by regex",
+#     "can't multiply type array by timestamp",
 #
-#     "can't multiply type \"object\" by \"string\"",
-#     "can't multiply type \"object\" by \"integer\"",
-#     "can't multiply type \"object\" by \"float\"",
-#     "can't multiply type \"object\" by \"boolean\"",
-#     "can't multiply type \"object\" by \"boolean\"",
-#     "can't multiply type \"object\" by \"null\"",
-#     "can't multiply type \"object\" by \"array\"",
-#     "can't multiply type \"object\" by \"object\"",
-#     "can't multiply type \"object\" by \"regex\"",
-#     "can't multiply type \"object\" by \"timestamp\"",
+#     "can't multiply type object by string",
+#     "can't multiply type object by integer",
+#     "can't multiply type object by float",
+#     "can't multiply type object by boolean",
+#     "can't multiply type object by boolean",
+#     "can't multiply type object by null",
+#     "can't multiply type object by array",
+#     "can't multiply type object by object",
+#     "can't multiply type object by regex",
+#     "can't multiply type object by timestamp",
 #
-#     "can't multiply type \"regex\" by \"string\"",
-#     "can't multiply type \"regex\" by \"integer\"",
-#     "can't multiply type \"regex\" by \"float\"",
-#     "can't multiply type \"regex\" by \"boolean\"",
-#     "can't multiply type \"regex\" by \"boolean\"",
-#     "can't multiply type \"regex\" by \"null\"",
-#     "can't multiply type \"regex\" by \"array\"",
-#     "can't multiply type \"regex\" by \"object\"",
-#     "can't multiply type \"regex\" by \"regex\"",
-#     "can't multiply type \"regex\" by \"timestamp\"",
+#     "can't multiply type regex by string",
+#     "can't multiply type regex by integer",
+#     "can't multiply type regex by float",
+#     "can't multiply type regex by boolean",
+#     "can't multiply type regex by boolean",
+#     "can't multiply type regex by null",
+#     "can't multiply type regex by array",
+#     "can't multiply type regex by object",
+#     "can't multiply type regex by regex",
+#     "can't multiply type regex by timestamp",
 #
-#     "can't multiply type \"timestamp\" by \"string\"",
-#     "can't multiply type \"timestamp\" by \"integer\"",
-#     "can't multiply type \"timestamp\" by \"float\"",
-#     "can't multiply type \"timestamp\" by \"boolean\"",
-#     "can't multiply type \"timestamp\" by \"boolean\"",
-#     "can't multiply type \"timestamp\" by \"null\"",
-#     "can't multiply type \"timestamp\" by \"array\"",
-#     "can't multiply type \"timestamp\" by \"object\"",
-#     "can't multiply type \"timestamp\" by \"regex\"",
-#     "can't multiply type \"timestamp\" by \"timestamp\""
+#     "can't multiply type timestamp by string",
+#     "can't multiply type timestamp by integer",
+#     "can't multiply type timestamp by float",
+#     "can't multiply type timestamp by boolean",
+#     "can't multiply type timestamp by boolean",
+#     "can't multiply type timestamp by null",
+#     "can't multiply type timestamp by array",
+#     "can't multiply type timestamp by object",
+#     "can't multiply type timestamp by regex",
+#     "can't multiply type timestamp by timestamp"
 # ]
 
 ok, err1 = 1 * true
diff --git a/lib/vrl/tests/tests/expressions/arithmetic/remainder/invalid.vrl b/lib/vrl/tests/tests/expressions/arithmetic/remainder/invalid.vrl
index 2e813cd2226af..b31e005f093da 100644
--- a/lib/vrl/tests/tests/expressions/arithmetic/remainder/invalid.vrl
+++ b/lib/vrl/tests/tests/expressions/arithmetic/remainder/invalid.vrl
@@ -1,96 +1,96 @@
 # result: [
-#     "can't calculate remainder of type \"integer\" and \"boolean\"",
-#     "can't calculate remainder of type \"integer\" and \"boolean\"",
-#     "can't calculate remainder of type \"integer\" and \"null\"",
-#     "can't calculate remainder of type \"integer\" and \"array\"",
-#     "can't calculate remainder of type \"integer\" and \"object\"",
-#     "can't calculate remainder of type \"integer\" and \"regex\"",
-#     "can't calculate remainder of type \"integer\" and \"timestamp\"",
+#     "can't calculate remainder of type integer and boolean",
+#     "can't calculate remainder of type integer and boolean",
+#     "can't calculate remainder of type integer and null",
+#     "can't calculate remainder of type integer and array",
+#     "can't calculate remainder of type integer and object",
+#     "can't calculate remainder of type integer and regex",
+#     "can't calculate remainder of type integer and timestamp",
 #
-#     "can't calculate remainder of type \"float\" and \"string\"",
-#     "can't calculate remainder of type \"float\" and \"boolean\"",
-#     "can't calculate remainder of type \"float\" and \"boolean\"",
-#     "can't calculate remainder of type \"float\" and \"null\"",
-#     "can't calculate remainder of type \"float\" and \"array\"",
-#     "can't calculate remainder of type \"float\" and \"object\"",
-#     "can't calculate remainder of type \"float\" and \"regex\"",
-#     "can't calculate remainder of type \"float\" and \"timestamp\"",
+#     "can't calculate remainder of type float and string",
+#     "can't calculate remainder of type float and boolean",
+#     "can't calculate remainder of type float and boolean",
+#     "can't calculate remainder of type float and null",
+#     "can't calculate remainder of type float and array",
+#     "can't calculate remainder of type float and object",
+#     "can't calculate remainder of type float and regex",
+#     "can't calculate remainder of type float and timestamp",
 #
-#     "can't calculate remainder of type \"string\" and \"string\"",
-#     "can't calculate remainder of type \"string\" and \"float\"",
-#     "can't calculate remainder of type \"string\" and \"boolean\"",
-#     "can't calculate remainder of type \"string\" and \"boolean\"",
-#     "can't calculate remainder of type \"string\" and \"null\"",
-#     "can't calculate remainder of type \"string\" and \"array\"",
-#     "can't calculate remainder of type \"string\" and \"object\"",
-#     "can't calculate remainder of type \"string\" and \"regex\"",
-#     "can't calculate remainder of type \"string\" and \"timestamp\"",
+#     "can't calculate remainder of type string and string",
+#     "can't calculate remainder of type string and float",
+#     "can't calculate remainder of type string and boolean",
+#     "can't calculate remainder of type string and boolean",
+#     "can't calculate remainder of type string and null",
+#     "can't calculate remainder of type string and array",
+#     "can't calculate remainder of type string and object",
+#     "can't calculate remainder of type string and regex",
+#     "can't calculate remainder of type string and timestamp",
 #
-#     "can't calculate remainder of type \"boolean\" and \"string\"",
-#     "can't calculate remainder of type \"boolean\" and \"integer\"",
-#     "can't calculate remainder of type \"boolean\" and \"float\"",
-#     "can't calculate remainder of type \"boolean\" and \"boolean\"",
-#     "can't calculate remainder of type \"boolean\" and \"boolean\"",
-#     "can't calculate remainder of type \"boolean\" and \"null\"",
-#     "can't calculate remainder of type \"boolean\" and \"array\"",
-#     "can't calculate remainder of type \"boolean\" and \"object\"",
-#     "can't calculate remainder of type \"boolean\" and \"regex\"",
-#     "can't calculate remainder of type \"boolean\" and \"timestamp\"",
+#     "can't calculate remainder of type boolean and string",
+#     "can't calculate remainder of type boolean and integer",
+#     "can't calculate remainder of type boolean and float",
+#     "can't calculate remainder of type boolean and boolean",
+#     "can't calculate remainder of type boolean and boolean",
+#     "can't calculate remainder of type boolean and null",
+#     "can't calculate remainder of type boolean and array",
+#     "can't calculate remainder of type boolean and object",
+#     "can't calculate remainder of type boolean and regex",
+#     "can't calculate remainder of type boolean and timestamp",
 #
-#     "can't calculate remainder of type \"null\" and \"string\"",
-#     "can't calculate remainder of type \"null\" and \"integer\"",
-#     "can't calculate remainder of type \"null\" and \"float\"",
-#     "can't calculate remainder of type \"null\" and \"boolean\"",
-#     "can't calculate remainder of type \"null\" and \"boolean\"",
-#     "can't calculate remainder of type \"null\" and \"null\"",
-#     "can't calculate remainder of type \"null\" and \"array\"",
-#     "can't calculate remainder of type \"null\" and \"object\"",
-#     "can't calculate remainder of type \"null\" and \"regex\"",
-#     "can't calculate remainder of type \"null\" and \"timestamp\"",
+#     "can't calculate remainder of type null and string",
+#     "can't calculate remainder of type null and integer",
+#     "can't calculate remainder of type null and float",
+#     "can't calculate remainder of type null and boolean",
+#     "can't calculate remainder of type null and boolean",
+#     "can't calculate remainder of type null and null",
+#     "can't calculate remainder of type null and array",
+#     "can't calculate remainder of type null and object",
+#     "can't calculate remainder of type null and regex",
+#     "can't calculate remainder of type null and timestamp",
 #
-#     "can't calculate remainder of type \"array\" and \"string\"",
-#     "can't calculate remainder of type \"array\" and \"integer\"",
-#     "can't calculate remainder of type \"array\" and \"float\"",
-#     "can't calculate remainder of type \"array\" and \"boolean\"",
-#     "can't calculate remainder of type \"array\" and \"boolean\"",
-#     "can't calculate remainder of type \"array\" and \"null\"",
-#     "can't calculate remainder of type \"array\" and \"array\"",
-#     "can't calculate remainder of type \"array\" and \"object\"",
-#     "can't calculate remainder of type \"array\" and \"regex\"",
-#     "can't calculate remainder of type \"array\" and \"timestamp\"",
+#     "can't calculate remainder of type array and string",
+#     "can't calculate remainder of type array and integer",
+#     "can't calculate remainder of type array and float",
+#     "can't calculate remainder of type array and boolean",
+#     "can't calculate remainder of type array and boolean",
+#     "can't calculate remainder of type array and null",
+#     "can't calculate remainder of type array and array",
+#     "can't calculate remainder of type array and object",
+#     "can't calculate remainder of type array and regex",
+#     "can't calculate remainder of type array and timestamp",
 #
-#     "can't calculate remainder of type \"object\" and \"string\"",
-#     "can't calculate remainder of type \"object\" and \"integer\"",
-#     "can't calculate remainder of type \"object\" and \"float\"",
-#     "can't calculate remainder of type \"object\" and \"boolean\"",
-#     "can't calculate remainder of type \"object\" and \"boolean\"",
-#     "can't calculate remainder of type \"object\" and \"null\"",
-#     "can't calculate remainder of type \"object\" and \"array\"",
-#     "can't calculate remainder of type \"object\" and \"object\"",
-#     "can't calculate remainder of type \"object\" and \"regex\"",
-#     "can't calculate remainder of type \"object\" and \"timestamp\"",
+#     "can't calculate remainder of type object and string",
+#     "can't calculate remainder of type object and integer",
+#     "can't calculate remainder of type object and float",
+#     "can't calculate remainder of type object and boolean",
+#     "can't calculate remainder of type object and boolean",
+#     "can't calculate remainder of type object and null",
+#     "can't calculate remainder of type object and array",
+#     "can't calculate remainder of type object and object",
+#     "can't calculate remainder of type object and regex",
+#     "can't calculate remainder of type object and timestamp",
 #
-#     "can't calculate remainder of type \"regex\" and \"string\"",
-#     "can't calculate remainder of type \"regex\" and \"integer\"",
-#     "can't calculate remainder of type \"regex\" and \"float\"",
-#     "can't calculate remainder of type \"regex\" and \"boolean\"",
-#     "can't calculate remainder of type \"regex\" and \"boolean\"",
-#     "can't calculate remainder of type \"regex\" and \"null\"",
-#     "can't calculate remainder of type \"regex\" and \"array\"",
-#     "can't calculate remainder of type \"regex\" and \"object\"",
-#     "can't calculate remainder of type \"regex\" and \"regex\"",
-#     "can't calculate remainder of type \"regex\" and \"timestamp\"",
+#     "can't calculate remainder of type regex and string",
+#     "can't calculate remainder of type regex and integer",
+#     "can't calculate remainder of type regex and float",
+#     "can't calculate remainder of type regex and boolean",
+#     "can't calculate remainder of type regex and boolean",
+#     "can't calculate remainder of type regex and null",
+#     "can't calculate remainder of type regex and array",
+#     "can't calculate remainder of type regex and object",
+#     "can't calculate remainder of type regex and regex",
+#     "can't calculate remainder of type regex and timestamp",
 #
-#     "can't calculate remainder of type \"timestamp\" and \"string\"",
-#     "can't calculate remainder of type \"timestamp\" and \"integer\"",
-#     "can't calculate remainder of type \"timestamp\" and \"float\"",
-#     "can't calculate remainder of type \"timestamp\" and \"boolean\"",
-#     "can't calculate remainder of type \"timestamp\" and \"boolean\"",
-#     "can't calculate remainder of type \"timestamp\" and \"null\"",
-#     "can't calculate remainder of type \"timestamp\" and \"array\"",
-#     "can't calculate remainder of type \"timestamp\" and \"object\"",
-#     "can't calculate remainder of type \"timestamp\" and \"regex\"",
-#     "can't calculate remainder of type \"timestamp\" and \"timestamp\""
+#     "can't calculate remainder of type timestamp and string",
+#     "can't calculate remainder of type timestamp and integer",
+#     "can't calculate remainder of type timestamp and float",
+#     "can't calculate remainder of type timestamp and boolean",
+#     "can't calculate remainder of type timestamp and boolean",
+#     "can't calculate remainder of type timestamp and null",
+#     "can't calculate remainder of type timestamp and array",
+#     "can't calculate remainder of type timestamp and object",
+#     "can't calculate remainder of type timestamp and regex",
+#     "can't calculate remainder of type timestamp and timestamp"
 # ]
 
 ok, err1 = 1 % true
diff --git a/lib/vrl/tests/tests/expressions/arithmetic/subtraction/invalid.vrl b/lib/vrl/tests/tests/expressions/arithmetic/subtraction/invalid.vrl
index 00418b5a5326c..99a8790b1db00 100644
--- a/lib/vrl/tests/tests/expressions/arithmetic/subtraction/invalid.vrl
+++ b/lib/vrl/tests/tests/expressions/arithmetic/subtraction/invalid.vrl
@@ -1,98 +1,98 @@
 # result: [
-#     "can't subtract type \"string\" from \"integer\"",
-#     "can't subtract type \"boolean\" from \"integer\"",
-#     "can't subtract type \"boolean\" from \"integer\"",
-#     "can't subtract type \"null\" from \"integer\"",
-#     "can't subtract type \"array\" from \"integer\"",
-#     "can't subtract type \"object\" from \"integer\"",
-#     "can't subtract type \"regex\" from \"integer\"",
-#     "can't subtract type \"timestamp\" from \"integer\"",
+#     "can't subtract type string from integer",
+#     "can't subtract type boolean from integer",
+#     "can't subtract type boolean from integer",
+#     "can't subtract type null from integer",
+#     "can't subtract type array from integer",
+#     "can't subtract type object from integer",
+#     "can't subtract type regex from integer",
+#     "can't subtract type timestamp from integer",
 #
-#     "can't subtract type \"string\" from \"float\"",
-#     "can't subtract type \"boolean\" from \"float\"",
-#     "can't subtract type \"boolean\" from \"float\"",
-#     "can't subtract type \"null\" from \"float\"",
-#     "can't subtract type \"array\" from \"float\"",
-#     "can't subtract type \"object\" from \"float\"",
-#     "can't subtract type \"regex\" from \"float\"",
-#     "can't subtract type \"timestamp\" from \"float\"",
+#     "can't subtract type string from float",
+#     "can't subtract type boolean from float",
+#     "can't subtract type boolean from float",
+#     "can't subtract type null from float",
+#     "can't subtract type array from float",
+#     "can't subtract type object from float",
+#     "can't subtract type regex from float",
+#     "can't subtract type timestamp from float",
 #
-#     "can't subtract type \"string\" from \"string\"",
-#     "can't subtract type \"integer\" from \"string\"",
-#     "can't subtract type \"float\" from \"string\"",
-#     "can't subtract type \"boolean\" from \"string\"",
-#     "can't subtract type \"boolean\" from \"string\"",
-#     "can't subtract type \"null\" from \"string\"",
-#     "can't subtract type \"array\" from \"string\"",
-#     "can't subtract type \"object\" from \"string\"",
-#     "can't subtract type \"regex\" from \"string\"",
-#     "can't subtract type \"timestamp\" from \"string\"",
+#     "can't subtract type string from string",
+#     "can't subtract type integer from string",
+#     "can't subtract type float from string",
+#     "can't subtract type boolean from string",
+#     "can't subtract type boolean from string",
+#     "can't subtract type null from string",
+#     "can't subtract type array from string",
+#     "can't subtract type object from string",
+#     "can't subtract type regex from string",
+#     "can't subtract type timestamp from string",
 #
-#     "can't subtract type \"string\" from \"boolean\"",
-#     "can't subtract type \"integer\" from \"boolean\"",
-#     "can't subtract type \"float\" from \"boolean\"",
-#     "can't subtract type \"boolean\" from \"boolean\"",
-#     "can't subtract type \"boolean\" from \"boolean\"",
-#     "can't subtract type \"null\" from \"boolean\"",
-#     "can't subtract type \"array\" from \"boolean\"",
-#     "can't subtract type \"object\" from \"boolean\"",
-#     "can't subtract type \"regex\" from \"boolean\"",
-#     "can't subtract type \"timestamp\" from \"boolean\"",
+#     "can't subtract type string from boolean",
+#     "can't subtract type integer from boolean",
+#     "can't subtract type float from boolean",
+#     "can't subtract type boolean from boolean",
+#     "can't subtract type boolean from boolean",
+#     "can't subtract type null from boolean",
+#     "can't subtract type array from boolean",
+#     "can't subtract type object from boolean",
+#     "can't subtract type regex from boolean",
+#     "can't subtract type timestamp from boolean",
 #
-#     "can't subtract type \"string\" from \"null\"",
-#     "can't subtract type \"integer\" from \"null\"",
-#     "can't subtract type \"float\" from \"null\"",
-#     "can't subtract type \"boolean\" from \"null\"",
-#     "can't subtract type \"boolean\" from \"null\"",
-#     "can't subtract type \"null\" from \"null\"",
-#     "can't subtract type \"array\" from \"null\"",
-#     "can't subtract type \"object\" from \"null\"",
-#     "can't subtract type \"regex\" from \"null\"",
-#     "can't subtract type \"timestamp\" from \"null\"",
+#     "can't subtract type string from null",
+#     "can't subtract type integer from null",
+#     "can't subtract type float from null",
+#     "can't subtract type boolean from null",
+#     "can't subtract type boolean from null",
+#     "can't subtract type null from null",
+#     "can't subtract type array from null",
+#     "can't subtract type object from null",
+#     "can't subtract type regex from null",
+#     "can't subtract type timestamp from null",
 #
-#     "can't subtract type \"string\" from \"array\"",
-#     "can't subtract type \"integer\" from \"array\"",
-#     "can't subtract type \"float\" from \"array\"",
-#     "can't subtract type \"boolean\" from \"array\"",
-#     "can't subtract type \"boolean\" from \"array\"",
-#     "can't subtract type \"null\" from \"array\"",
-#     "can't subtract type \"array\" from \"array\"",
-#     "can't subtract type \"object\" from \"array\"",
-#     "can't subtract type \"regex\" from \"array\"",
-#     "can't subtract type \"timestamp\" from \"array\"",
+#     "can't subtract type string from array",
+#     "can't subtract type integer from array",
+#     "can't subtract type float from array",
+#     "can't subtract type boolean from array",
+#     "can't subtract type boolean from array",
+#     "can't subtract type null from array",
+#     "can't subtract type array from array",
+#     "can't subtract type object from array",
+#     "can't subtract type regex from array",
+#     "can't subtract type timestamp from array",
 #
-#     "can't subtract type \"string\" from \"object\"",
-#     "can't subtract type \"integer\" from \"object\"",
-#     "can't subtract type \"float\" from \"object\"",
-#     "can't subtract type \"boolean\" from \"object\"",
-#     "can't subtract type \"boolean\" from \"object\"",
-#     "can't subtract type \"null\" from \"object\"",
-#     "can't subtract type \"array\" from \"object\"",
-#     "can't subtract type \"object\" from \"object\"",
-#     "can't subtract type \"regex\" from \"object\"",
-#     "can't subtract type \"timestamp\" from \"object\"",
+#     "can't subtract type string from object",
+#     "can't subtract type integer from object",
+#     "can't subtract type float from object",
+#     "can't subtract type boolean from object",
+#     "can't subtract type boolean from object",
+#     "can't subtract type null from object",
+#     "can't subtract type array from object",
+#     "can't subtract type object from object",
+#     "can't subtract type regex from object",
+#     "can't subtract type timestamp from object",
 #
-#     "can't subtract type \"string\" from \"regex\"",
-#     "can't subtract type \"integer\" from \"regex\"",
-#     "can't subtract type \"float\" from \"regex\"",
-#     "can't subtract type \"boolean\" from \"regex\"",
-#     "can't subtract type \"boolean\" from \"regex\"",
-#     "can't subtract type \"null\" from \"regex\"",
-#     "can't subtract type \"array\" from \"regex\"",
-#     "can't subtract type \"object\" from \"regex\"",
-#     "can't subtract type \"regex\" from \"regex\"",
-#     "can't subtract type \"timestamp\" from \"regex\"",
+#     "can't subtract type string from regex",
+#     "can't subtract type integer from regex",
+#     "can't subtract type float from regex",
+#     "can't subtract type boolean from regex",
+#     "can't subtract type boolean from regex",
+#     "can't subtract type null from regex",
+#     "can't subtract type array from regex",
+#     "can't subtract type object from regex",
+#     "can't subtract type regex from regex",
+#     "can't subtract type timestamp from regex",
 #
-#     "can't subtract type \"string\" from \"timestamp\"",
-#     "can't subtract type \"integer\" from \"timestamp\"",
-#     "can't subtract type \"float\" from \"timestamp\"",
-#     "can't subtract type \"boolean\" from \"timestamp\"",
-#     "can't subtract type \"boolean\" from \"timestamp\"",
-#     "can't subtract type \"null\" from \"timestamp\"",
-#     "can't subtract type \"array\" from \"timestamp\"",
-#     "can't subtract type \"object\" from \"timestamp\"",
-#     "can't subtract type \"regex\" from \"timestamp\"",
-#     "can't subtract type \"timestamp\" from \"timestamp\""
+#     "can't subtract type string from timestamp",
+#     "can't subtract type integer from timestamp",
+#     "can't subtract type float from timestamp",
+#     "can't subtract type boolean from timestamp",
+#     "can't subtract type boolean from timestamp",
+#     "can't subtract type null from timestamp",
+#     "can't subtract type array from timestamp",
+#     "can't subtract type object from timestamp",
+#     "can't subtract type regex from timestamp",
+#     "can't subtract type timestamp from timestamp"
 # ]
 
 ok, err1 = 1 - "foo"
diff --git a/lib/vrl/tests/tests/issues/11287_http_pipelines_blackhole.vrl b/lib/vrl/tests/tests/issues/11287_http_pipelines_blackhole.vrl
new file mode 100644
index 0000000000000..bc069658783c8
--- /dev/null
+++ b/lib/vrl/tests/tests/issues/11287_http_pipelines_blackhole.vrl
@@ -0,0 +1,13 @@
+# issue: https://github.com/vectordotdev/vector/pull/11287
+# result: [["bar"], ["qux"], { "bar": true }]
+
+.a1, err = push(.a1, "foo")
+.a1 = push(.a1, "bar")
+
+.a2, err = append(.a2, ["baz"])
+.a2 = append(.a2, ["qux"])
+
+.a3, err = merge(.a3, { "foo": true })
+.a3 = merge(.a3, { "bar": true })
+
+[.a1, .a2, .a3]
diff --git a/src/transforms/remap.rs b/src/transforms/remap.rs
index ec2254d3a2af6..e1aa097445e3f 100644
--- a/src/transforms/remap.rs
+++ b/src/transforms/remap.rs
@@ -738,7 +738,7 @@ mod tests {
             serde_json::json!({
                 "dropped": {
                     "reason": "error",
-                    "message": "function call error for \"string\" at (160:175): expected \"string\", got \"integer\"",
+                    "message": "function call error for \"string\" at (160:175): expected string, got integer",
                     "component_id": "remapper",
                     "component_type": "remap",
                     "component_kind": "transform",
diff --git a/website/cue/reference/remap.cue b/website/cue/reference/remap.cue
index b451cbd28cf00..1cfaa7caacae4 100644
--- a/website/cue/reference/remap.cue
+++ b/website/cue/reference/remap.cue
@@ -212,8 +212,8 @@ remap: #Remap & {
 				1 │ upcase(42)
 				  │        ^^
 				  │        │
-				  │        this expression resolves to the exact type "integer"
-				  │        but the parameter "value" expects the exact type "string"
+				  │        this expression resolves to the exact type integer
+				  │        but the parameter "value" expects the exact type string
 				  │
 				  = try: ensuring an appropriate type at runtime
 				  =
diff --git a/website/cue/reference/remap/functions/timestamp.cue b/website/cue/reference/remap/functions/timestamp.cue
index ae03b2f04658c..0599551fef395 100644
--- a/website/cue/reference/remap/functions/timestamp.cue
+++ b/website/cue/reference/remap/functions/timestamp.cue
@@ -32,7 +32,7 @@ remap: functions: timestamp: {
 			source: #"""
 				ok, err = timestamp(.timestamp)
 				"""#
-			return: "function call error for \"timestamp\" at (10:31): expected \"timestamp\", got \"string\""
+			return: "function call error for \"timestamp\" at (10:31): expected timestamp, got string"
 		},
 	]
 }