spiral-sdk 0.1.10

// Generated by `cargo run -p engine-xtask -- spql-registry` from spql/registry/spql-types.v1.json.
// Do not edit by hand.

use std::sync::Arc;

use arrow_schema::{DataType, Field, Fields, TimeUnit};

use super::{
    Bridge, Bridges, DurationUnit, ExtensionParams, Kind, PeriodFrequency, SpqlType, Stability,
    TypeError, TypeParam,
};

/// The registry's catalog version.
pub const CATALOG_VERSION: &str = "1.0";

/// Collection of image-space annotations.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Annotations2D;

impl SpqlType for Annotations2D {
    const ID: &'static str = "spql.Annotations2D";
    const NAME: &'static str = "Annotations2D";
    const ARROW_NAME: &'static str = "spql.Annotations2D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "annotation";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "circles",
                DataType::List(Arc::new(Circle2D.field("item", false))),
                true,
            ),
            Field::new(
                "points",
                DataType::List(Arc::new(Points2D.field("item", false))),
                true,
            ),
            Field::new(
                "text",
                DataType::List(Arc::new(Text2D.field("item", false))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed three-dimensional arrow.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Arrow3D;

impl SpqlType for Arrow3D {
    const ID: &'static str = "spql.Arrow3D";
    const NAME: &'static str = "Arrow3D";
    const ARROW_NAME: &'static str = "spql.Arrow3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Field::new("shaft_length", DataType::Float64, false),
            Field::new("shaft_diameter", DataType::Float64, false),
            Field::new("head_length", DataType::Float64, false),
            Field::new("head_diameter", DataType::Float64, false),
            Color.field("color", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Decoded PCM samples.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct AudioBuffer;

impl SpqlType for AudioBuffer {
    const ID: &'static str = "spql.AudioBuffer";
    const NAME: &'static str = "AudioBuffer";
    const ARROW_NAME: &'static str = "spql.AudioBuffer";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "audio";
    const KIND: Kind = Kind::Decoded;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("data", DataType::Binary, false),
            Field::new("sample_format", DataType::Utf8, false),
            Field::new("sample_rate", DataType::UInt32, false),
            Field::new("channels", DataType::UInt32, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Inline bytes, a Spiral address or a direct provider URI, exposed as `spql.Blob`.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Blob;

impl SpqlType for Blob {
    const ID: &'static str = "spql.Blob";
    const NAME: &'static str = "Blob";
    const ARROW_NAME: &'static str = "spql.Blob";
    const ALIASES: &'static [&'static str] = &["spql.io.Blob"];
    const FAMILY: &'static str = "blob";
    const KIND: Kind = Kind::Reference;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("bytes", DataType::Binary, true),
            Field::new("uri", DataType::Utf8, true),
            Field::new("offset", DataType::UInt64, true),
            Field::new("size", DataType::UInt64, true),
            Field::new("mime_type", DataType::Utf8, true),
            Field::new("version", DataType::Utf8, true),
            Field::new("etag", DataType::Utf8, true),
            Field::new("digest", DataType::Binary, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed three-dimensional box.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Box3D;

impl SpqlType for Box3D {
    const ID: &'static str = "spql.Box3D";
    const NAME: &'static str = "Box3D";
    const ARROW_NAME: &'static str = "spql.Box3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Vector3D.field("size", false),
            Color.field("color", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Foxglove CameraCalibration and ROS CameraInfo fields; a pinhole has no distortion.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct CameraCalibration;

impl SpqlType for CameraCalibration {
    const ID: &'static str = "spql.CameraCalibration";
    const NAME: &'static str = "CameraCalibration";
    const ARROW_NAME: &'static str = "spql.CameraCalibration";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "camera";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("width", DataType::UInt32, false),
            Field::new("height", DataType::UInt32, false),
            Field::new("distortion_model", DataType::Utf8, true),
            Field::new(
                "distortion_coefficients",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new(
                "intrinsic",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                false,
            ),
            Field::new(
                "rectification",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new(
                "projection",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Styled image-space circle.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Circle2D;

impl SpqlType for Circle2D {
    const ID: &'static str = "spql.Circle2D";
    const NAME: &'static str = "Circle2D";
    const ARROW_NAME: &'static str = "spql.Circle2D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "annotation";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Position2D.field("center", false),
            Field::new("radius", DataType::Float64, false),
            Field::new("thickness", DataType::Float64, true),
            Color.field("fill_color", true),
            Color.field("outline_color", true),
            Field::new(
                "metadata",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_key_value_storage(),
                    false,
                ))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A half-open encoded temporal selection over some or all streams of a media asset.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct ClipRef;

impl SpqlType for ClipRef {
    const ID: &'static str = "spql.ClipRef";
    const NAME: &'static str = "ClipRef";
    const ARROW_NAME: &'static str = "spql.ClipRef";
    const ALIASES: &'static [&'static str] = &["spql.media.ClipRef"];
    const FAMILY: &'static str = "media";
    const KIND: Kind = Kind::Reference;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            EncodedMedia.field("media", true),
            Field::new(
                "stream_indices",
                DataType::List(Arc::new(Field::new("item", DataType::Int32, false))),
                true,
            ),
            Field::new("start", DataType::Duration(TimeUnit::Nanosecond), true),
            Field::new("end", DataType::Duration(TimeUnit::Nanosecond), true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Unit-interval RGBA color.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Color;

impl SpqlType for Color {
    const ID: &'static str = "spql.Color";
    const NAME: &'static str = "Color";
    const ARROW_NAME: &'static str = "spql.Color";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("r", DataType::Float64, false),
            Field::new("g", DataType::Float64, false),
            Field::new("b", DataType::Float64, false),
            Field::new("a", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed cylinder or frustum.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Cylinder3D;

impl SpqlType for Cylinder3D {
    const ID: &'static str = "spql.Cylinder3D";
    const NAME: &'static str = "Cylinder3D";
    const ARROW_NAME: &'static str = "spql.Cylinder3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Vector3D.field("size", false),
            Field::new("top_scale", DataType::Float64, false),
            Field::new("bottom_scale", DataType::Float64, false),
            Color.field("color", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A two-dimensional depth value: rank-two f32 sample and confidence tensors shaped `[height,
/// width]`, the representation of the samples and an optional linear calibration.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct DepthMap;

impl SpqlType for DepthMap {
    const ID: &'static str = "spql.DepthMap";
    const NAME: &'static str = "DepthMap";
    const ARROW_NAME: &'static str = "spql.DepthMap";
    const ALIASES: &'static [&'static str] = &["spql.depth.DepthMap"];
    const FAMILY: &'static str = "depth";
    const KIND: Kind = Kind::Decoded;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "values",
                DataType::Struct(Fields::from(vec![
                    Field::new(
                        "data",
                        DataType::List(Arc::new(Field::new("item", DataType::Float32, false))),
                        false,
                    ),
                    Field::new(
                        "shape",
                        DataType::FixedSizeList(
                            Arc::new(Field::new("item", DataType::Int32, false)),
                            2,
                        ),
                        false,
                    ),
                ])),
                true,
            ),
            Field::new(
                "confidence",
                DataType::Struct(Fields::from(vec![
                    Field::new(
                        "data",
                        DataType::List(Arc::new(Field::new("item", DataType::Float32, false))),
                        false,
                    ),
                    Field::new(
                        "shape",
                        DataType::FixedSizeList(
                            Arc::new(Field::new("item", DataType::Int32, false)),
                            2,
                        ),
                        false,
                    ),
                ])),
                true,
            ),
            Field::new("width", DataType::UInt32, false),
            Field::new("height", DataType::UInt32, false),
            Field::new("representation", DataType::Utf8, false),
            Field::new("unit", DataType::Utf8, true),
            Field::new("scale", DataType::Float32, true),
            Field::new("offset", DataType::Float32, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Fixed elapsed time in the parameter's unit.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct Duration {
    pub unit: DurationUnit,
}

impl SpqlType for Duration {
    const ID: &'static str = "spql.Duration";
    const NAME: &'static str = "Duration";
    const ARROW_NAME: &'static str = "spql.Duration";
    const ALIASES: &'static [&'static str] = &["spql.dt.Duration"];
    const FAMILY: &'static str = "dt";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Duration(self.unit.arrow_unit())
    }

    fn params(&self) -> Vec<(&'static str, &'static str)> {
        vec![("unit", self.unit.to_param())]
    }

    fn from_params(params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self {
            unit: params.take("unit")?,
        })
    }
}

/// A lazy encoded image over a Blob with the facts a header read can give.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct EncodedImage;

impl SpqlType for EncodedImage {
    const ID: &'static str = "spql.EncodedImage";
    const NAME: &'static str = "EncodedImage";
    const ARROW_NAME: &'static str = "spql.EncodedImage";
    const ALIASES: &'static [&'static str] = &["spql.image.EncodedImage"];
    const FAMILY: &'static str = "image";
    const KIND: Kind = Kind::Encoded;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Blob.field("source", true),
            Field::new("format", DataType::Utf8, true),
            Field::new("mime_type", DataType::Utf8, true),
            Field::new("width", DataType::UInt32, true),
            Field::new("height", DataType::UInt32, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Blob-backed encoded temporal media with an optional container name and index.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct EncodedMedia;

impl SpqlType for EncodedMedia {
    const ID: &'static str = "spql.EncodedMedia";
    const NAME: &'static str = "EncodedMedia";
    const ARROW_NAME: &'static str = "spql.EncodedMedia";
    const ALIASES: &'static [&'static str] = &["spql.media.EncodedMedia"];
    const FAMILY: &'static str = "media";
    const KIND: Kind = Kind::Encoded;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Blob.field("source", true),
            Field::new("container", DataType::Utf8, true),
            MediaIndex.field("index", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A normalized encoded packet with exact timing in its stream's time base and a Blob payload.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct EncodedPacket;

impl SpqlType for EncodedPacket {
    const ID: &'static str = "spql.EncodedPacket";
    const NAME: &'static str = "EncodedPacket";
    const ARROW_NAME: &'static str = "spql.EncodedPacket";
    const ALIASES: &'static [&'static str] = &["spql.media.EncodedPacket"];
    const FAMILY: &'static str = "media";
    const KIND: Kind = Kind::Encoded;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Blob.field("payload", true),
            StreamRef.field("stream", true),
            Field::new("codec", DataType::Utf8, true),
            Field::new("framing", DataType::Utf8, true),
            Field::new("pts", DataType::Int64, true),
            Field::new("dts", DataType::Int64, true),
            Field::new("duration_ticks", DataType::Int64, true),
            Field::new("time_base_num", DataType::Int32, true),
            Field::new("time_base_den", DataType::Int32, true),
            Field::new("keyframe", DataType::Boolean, true),
            Blob.field("codec_config", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// An encoded point cloud, such as PCD, LAS, LAZ or Draco, over a Blob.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct EncodedPointCloud;

impl SpqlType for EncodedPointCloud {
    const ID: &'static str = "spql.EncodedPointCloud";
    const NAME: &'static str = "EncodedPointCloud";
    const ARROW_NAME: &'static str = "spql.EncodedPointCloud";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pointcloud";
    const KIND: Kind = Kind::Encoded;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Blob.field("source", false),
            Field::new("format", DataType::Utf8, false),
            Pose3D.field("pose", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Ordered presentation-frame positions for spql.video.frames. Order and duplicates are preserved.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct FrameIndices;

impl SpqlType for FrameIndices {
    const ID: &'static str = "spql.FrameIndices";
    const NAME: &'static str = "FrameIndices";
    const ARROW_NAME: &'static str = "spql.FrameIndices";
    const ALIASES: &'static [&'static str] = &["spql.video.selection.FrameIndices"];
    const FAMILY: &'static str = "video";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![Field::new(
            "indices",
            DataType::List(Arc::new(Field::new("item", DataType::Int64, false))),
            false,
        )]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A fixed-count frame neighborhood around a presentation time, for spql.video.frames.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct FrameNeighborhood;

impl SpqlType for FrameNeighborhood {
    const ID: &'static str = "spql.FrameNeighborhood";
    const NAME: &'static str = "FrameNeighborhood";
    const ARROW_NAME: &'static str = "spql.FrameNeighborhood";
    const ALIASES: &'static [&'static str] = &["spql.video.selection.FrameNeighborhood"];
    const FAMILY: &'static str = "video";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("time", DataType::Duration(TimeUnit::Nanosecond), false),
            Field::new("count", DataType::UInt32, false),
            Field::new("start_offset", DataType::Int64, true),
            Field::new("step", DataType::Int64, true),
            Field::new("mode", DataType::Utf8, true),
            Field::new("boundary", DataType::Utf8, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// One presentation frame without pixels. A valid row sets exactly one of `stream`, resolved
/// through the media's index, or `packets`, the decode-order packets of the MCAP path.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct FrameRef;

impl SpqlType for FrameRef {
    const ID: &'static str = "spql.FrameRef";
    const NAME: &'static str = "FrameRef";
    const ARROW_NAME: &'static str = "spql.FrameRef";
    const ALIASES: &'static [&'static str] = &["spql.video.FrameRef"];
    const FAMILY: &'static str = "video";
    const KIND: Kind = Kind::Reference;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            StreamRef.field("stream", true),
            Field::new(
                "packets",
                DataType::List(Arc::new(EncodedPacket.field("item", true))),
                true,
            ),
            Field::new("presentation_index", DataType::Int64, true),
            Field::new("decode_index", DataType::Int64, true),
            Field::new("pts", DataType::Int64, true),
            Field::new("dts", DataType::Int64, true),
            Field::new("duration_ticks", DataType::Int64, true),
            Field::new("time_base_num", DataType::Int32, true),
            Field::new("time_base_den", DataType::Int32, true),
            Field::new("keyframe", DataType::Boolean, true),
            Field::new("group_id", DataType::Utf8, true),
            Field::new("local_index", DataType::Int64, true),
            Blob.field("codec_config", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A half-open slice over display-order presentation-frame positions, for spql.video.frames.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct FrameSlice;

impl SpqlType for FrameSlice {
    const ID: &'static str = "spql.FrameSlice";
    const NAME: &'static str = "FrameSlice";
    const ARROW_NAME: &'static str = "spql.FrameSlice";
    const ALIASES: &'static [&'static str] = &["spql.video.selection.FrameSlice"];
    const FAMILY: &'static str = "video";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("start", DataType::Int64, true),
            Field::new("stop", DataType::Int64, true),
            Field::new("step", DataType::Int64, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Ordered presentation times that spql.video.frames resolves to frames. Order and duplicates are
/// preserved.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct FrameTimes;

impl SpqlType for FrameTimes {
    const ID: &'static str = "spql.FrameTimes";
    const NAME: &'static str = "FrameTimes";
    const ARROW_NAME: &'static str = "spql.FrameTimes";
    const ALIASES: &'static [&'static str] = &["spql.video.selection.FrameTimes"];
    const FAMILY: &'static str = "video";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "times",
                DataType::List(Arc::new(Field::new(
                    "item",
                    DataType::Duration(TimeUnit::Nanosecond),
                    false,
                ))),
                false,
            ),
            Field::new("mode", DataType::Utf8, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Geographic position in latitude, longitude, and altitude.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct GeoPosition;

impl SpqlType for GeoPosition {
    const ID: &'static str = "spql.GeoPosition";
    const NAME: &'static str = "GeoPosition";
    const ARROW_NAME: &'static str = "spql.GeoPosition";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "navigation";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("latitude", DataType::Float64, false),
            Field::new("longitude", DataType::Float64, false),
            Field::new("altitude", DataType::Float64, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A two-dimensional grid of packed cells; Foxglove Grid layout.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Grid;

impl SpqlType for Grid {
    const ID: &'static str = "spql.Grid";
    const NAME: &'static str = "Grid";
    const ARROW_NAME: &'static str = "spql.Grid";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pointcloud";
    const KIND: Kind = Kind::Decoded;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", true),
            Field::new("column_count", DataType::UInt32, false),
            Vector2D.field("cell_size", false),
            Field::new("row_stride", DataType::UInt32, false),
            Field::new("cell_stride", DataType::UInt32, false),
            Field::new(
                "fields",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_packed_field_storage(),
                    false,
                ))),
                false,
            ),
            Field::new("data", DataType::Binary, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Decoded display image: contiguous top-left-origin HWC pixels, treated as sRGB. Each row's
/// `pixel_format` fixes its channel layout: 1 is RGB8 and 2 is RGBA8 with straight alpha.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Image;

impl SpqlType for Image {
    const ID: &'static str = "spql.Image";
    const NAME: &'static str = "Image";
    const ARROW_NAME: &'static str = "spql.Image";
    const ALIASES: &'static [&'static str] = &["spql.image.Image"];
    const FAMILY: &'static str = "image";
    const KIND: Kind = Kind::Decoded;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "data",
                DataType::List(Arc::new(Field::new("item", DataType::UInt8, false))),
                false,
            ),
            Field::new("width", DataType::UInt32, false),
            Field::new("height", DataType::UInt32, false),
            Field::new("pixel_format", DataType::UInt8, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Encoded images in presentation order at a fixed rate; every frame decodes alone.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct ImageSequence;

impl SpqlType for ImageSequence {
    const ID: &'static str = "spql.ImageSequence";
    const NAME: &'static str = "ImageSequence";
    const ARROW_NAME: &'static str = "spql.ImageSequence";
    const ALIASES: &'static [&'static str] = &["spql.video.ImageSequence"];
    const FAMILY: &'static str = "video";
    const KIND: Kind = Kind::Encoded;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "images",
                DataType::List(Arc::new(EncodedImage.field("item", true))),
                false,
            ),
            Field::new("frame_rate", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Calendar-relative SQL interval.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Interval;

impl SpqlType for Interval {
    const ID: &'static str = "spql.Interval";
    const NAME: &'static str = "Interval";
    const ARROW_NAME: &'static str = "spql.Interval";
    const ALIASES: &'static [&'static str] = &["spql.dt.Interval"];
    const FAMILY: &'static str = "dt";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("months", DataType::Int32, true),
            Field::new("days", DataType::Int32, true),
            Field::new("nanos", DataType::Int64, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Instantaneous state of one revolute or prismatic joint.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct JointState;

impl SpqlType for JointState {
    const ID: &'static str = "spql.JointState";
    const NAME: &'static str = "JointState";
    const ARROW_NAME: &'static str = "spql.JointState";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "kinematics";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("name", DataType::Utf8, false),
            Field::new("position", DataType::Float64, true),
            Field::new("velocity", DataType::Float64, true),
            Field::new("acceleration", DataType::Float64, true),
            Field::new("effort", DataType::Float64, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A labeled axis-aligned bounding box with optional confidence.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct LabeledBox;

impl SpqlType for LabeledBox {
    const ID: &'static str = "spql.LabeledBox";
    const NAME: &'static str = "LabeledBox";
    const ARROW_NAME: &'static str = "spql.LabeledBox";
    const ALIASES: &'static [&'static str] = &["spql.detect.LabeledBox"];
    const FAMILY: &'static str = "detect";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("label", DataType::Utf8, false),
            Field::new(
                "bbox",
                DataType::Struct(Fields::from(vec![
                    Field::new("xmin", DataType::Float64, false),
                    Field::new("ymin", DataType::Float64, false),
                    Field::new("xmax", DataType::Float64, false),
                    Field::new("ymax", DataType::Float64, false),
                ])),
                false,
            ),
            Field::new("score", DataType::Float32, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Planar range scan sample.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct LaserScan;

impl SpqlType for LaserScan {
    const ID: &'static str = "spql.LaserScan";
    const NAME: &'static str = "LaserScan";
    const ARROW_NAME: &'static str = "spql.LaserScan";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pointcloud";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Field::new("start_angle", DataType::Float64, false),
            Field::new("end_angle", DataType::Float64, false),
            Field::new(
                "ranges",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                false,
            ),
            Field::new(
                "intensities",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed three-dimensional line topology.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Line3D;

impl SpqlType for Line3D {
    const ID: &'static str = "spql.Line3D";
    const NAME: &'static str = "Line3D";
    const ARROW_NAME: &'static str = "spql.Line3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Field::new(
                "points",
                DataType::List(Arc::new(Position3D.field("item", false))),
                false,
            ),
            Color.field("color", true),
            Field::new(
                "colors",
                DataType::List(Arc::new(Color.field("item", false))),
                true,
            ),
            Field::new(
                "indices",
                DataType::List(Arc::new(Field::new("item", DataType::UInt32, false))),
                true,
            ),
            Field::new("topology", DataType::Utf8, false),
            Field::new("thickness", DataType::Float64, true),
            Field::new("scale_invariant", DataType::Boolean, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Instantaneous geographic location estimate.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct LocationFix;

impl SpqlType for LocationFix {
    const ID: &'static str = "spql.LocationFix";
    const NAME: &'static str = "LocationFix";
    const ARROW_NAME: &'static str = "spql.LocationFix";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "navigation";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            GeoPosition.field("position", false),
            Field::new(
                "covariance",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new("covariance_type", DataType::Int32, true),
            Field::new("heading", DataType::Float64, true),
            Vector3D.field("velocity", true),
            Color.field("color", true),
            Field::new(
                "metadata",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_key_value_storage(),
                    false,
                ))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// One structured log record.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct LogEntry;

impl SpqlType for LogEntry {
    const ID: &'static str = "spql.LogEntry";
    const NAME: &'static str = "LogEntry";
    const ARROW_NAME: &'static str = "spql.LogEntry";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "log";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("level", DataType::Int32, false),
            Field::new("message", DataType::Utf8, false),
            Field::new("name", DataType::Utf8, true),
            Field::new("file", DataType::Utf8, true),
            Field::new("line", DataType::UInt32, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Index of one encoded media value: per track, the container's sample tables and a GOP table, from
/// which presentation order, byte offsets and each frame's decode closure are derived on read. Row
/// data, never layout or dtype metadata; an EncodedMedia carries it in its `index` field.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct MediaIndex;

impl SpqlType for MediaIndex {
    const ID: &'static str = "spql.MediaIndex";
    const NAME: &'static str = "MediaIndex";
    const ARROW_NAME: &'static str = "spql.MediaIndex";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "media";
    const KIND: Kind = Kind::Index;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("primary_track_id", DataType::UInt32, false),
            Field::new(
                "tracks",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_media_index_media_track_storage(),
                    false,
                ))),
                false,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed triangle mesh.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Mesh3D;

impl SpqlType for Mesh3D {
    const ID: &'static str = "spql.Mesh3D";
    const NAME: &'static str = "Mesh3D";
    const ARROW_NAME: &'static str = "spql.Mesh3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Field::new(
                "vertices",
                DataType::List(Arc::new(Position3D.field("item", false))),
                false,
            ),
            Field::new(
                "indices",
                DataType::List(Arc::new(Field::new("item", DataType::UInt32, false))),
                true,
            ),
            Color.field("color", true),
            Field::new(
                "colors",
                DataType::List(Arc::new(Color.field("item", false))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed model asset reference or embedded payload.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Model3D;

impl SpqlType for Model3D {
    const ID: &'static str = "spql.Model3D";
    const NAME: &'static str = "Model3D";
    const ARROW_NAME: &'static str = "spql.Model3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Vector3D.field("scale", true),
            Blob.field("source", true),
            Field::new("media_type", DataType::Utf8, true),
            Color.field("color", true),
            Field::new("override_color", DataType::Boolean, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Instantaneous pose and velocity estimate.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Odometry;

impl SpqlType for Odometry {
    const ID: &'static str = "spql.Odometry";
    const NAME: &'static str = "Odometry";
    const ARROW_NAME: &'static str = "spql.Odometry";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "navigation";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Vector3D.field("linear_velocity", true),
            Vector3D.field("angular_velocity", true),
            Field::new(
                "pose_covariance",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new(
                "velocity_covariance",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new(
                "metadata",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_key_value_storage(),
                    false,
                ))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Regular period label at the parameter's frequency.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct Period {
    pub freq: PeriodFrequency,
}

impl SpqlType for Period {
    const ID: &'static str = "spql.Period";
    const NAME: &'static str = "Period";
    const ARROW_NAME: &'static str = "spql.Period";
    const ALIASES: &'static [&'static str] = &["spql.dt.Period"];
    const FAMILY: &'static str = "dt";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Int64
    }

    fn params(&self) -> Vec<(&'static str, &'static str)> {
        vec![("freq", self.freq.to_param())]
    }

    fn from_params(params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self {
            freq: params.take("freq")?,
        })
    }
}

/// Packed points with a field table; Foxglove PointCloud and ROS PointCloud2 layout.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct PointCloud;

impl SpqlType for PointCloud {
    const ID: &'static str = "spql.PointCloud";
    const NAME: &'static str = "PointCloud";
    const ARROW_NAME: &'static str = "spql.PointCloud";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pointcloud";
    const KIND: Kind = Kind::Decoded;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", true),
            Field::new("point_stride", DataType::UInt32, false),
            Field::new(
                "fields",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_packed_field_storage(),
                    false,
                ))),
                false,
            ),
            Field::new("data", DataType::Binary, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Aligned two-dimensional point components.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Points2D;

impl SpqlType for Points2D {
    const ID: &'static str = "spql.Points2D";
    const NAME: &'static str = "Points2D";
    const ARROW_NAME: &'static str = "spql.Points2D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "positions",
                DataType::List(Arc::new(Position2D.field("item", false))),
                false,
            ),
            Field::new(
                "colors",
                DataType::List(Arc::new(Color.field("item", false))),
                true,
            ),
            Field::new(
                "radii",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new(
                "labels",
                DataType::List(Arc::new(Field::new("item", DataType::Utf8, false))),
                true,
            ),
            Field::new("topology", DataType::Utf8, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Aligned three-dimensional point components.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Points3D;

impl SpqlType for Points3D {
    const ID: &'static str = "spql.Points3D";
    const NAME: &'static str = "Points3D";
    const ARROW_NAME: &'static str = "spql.Points3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "positions",
                DataType::List(Arc::new(Position3D.field("item", false))),
                false,
            ),
            Field::new(
                "colors",
                DataType::List(Arc::new(Color.field("item", false))),
                true,
            ),
            Field::new(
                "radii",
                DataType::List(Arc::new(Field::new("item", DataType::Float64, false))),
                true,
            ),
            Field::new(
                "labels",
                DataType::List(Arc::new(Field::new("item", DataType::Utf8, false))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Position and orientation of one object in the row's frame.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Pose3D;

impl SpqlType for Pose3D {
    const ID: &'static str = "spql.Pose3D";
    const NAME: &'static str = "Pose3D";
    const ARROW_NAME: &'static str = "spql.Pose3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Position3D.field("position", false),
            Quaternion.field("orientation", false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Two-dimensional position in a declared coordinate system.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Position2D;

impl SpqlType for Position2D {
    const ID: &'static str = "spql.Position2D";
    const NAME: &'static str = "Position2D";
    const ARROW_NAME: &'static str = "spql.Position2D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("x", DataType::Float64, false),
            Field::new("y", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Three-dimensional position in a declared coordinate system.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Position3D;

impl SpqlType for Position3D {
    const ID: &'static str = "spql.Position3D";
    const NAME: &'static str = "Position3D";
    const ARROW_NAME: &'static str = "spql.Position3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("x", DataType::Float64, false),
            Field::new("y", DataType::Float64, false),
            Field::new("z", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Unit quaternion in x, y, z, w order.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Quaternion;

impl SpqlType for Quaternion {
    const ID: &'static str = "spql.Quaternion";
    const NAME: &'static str = "Quaternion";
    const ARROW_NAME: &'static str = "spql.Quaternion";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("x", DataType::Float64, false),
            Field::new("y", DataType::Float64, false),
            Field::new("z", DataType::Float64, false),
            Field::new("w", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Identified collection of three-dimensional primitives.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct SceneEntity3D;

impl SpqlType for SceneEntity3D {
    const ID: &'static str = "spql.SceneEntity3D";
    const NAME: &'static str = "SceneEntity3D";
    const ARROW_NAME: &'static str = "spql.SceneEntity3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("id", DataType::Utf8, false),
            Field::new("frame_id", DataType::Utf8, false),
            Field::new("lifetime_ns", DataType::Int64, true),
            Field::new("frame_locked", DataType::Boolean, true),
            Field::new(
                "arrows",
                DataType::List(Arc::new(Arrow3D.field("item", false))),
                true,
            ),
            Field::new(
                "boxes",
                DataType::List(Arc::new(Box3D.field("item", false))),
                true,
            ),
            Field::new(
                "cylinders",
                DataType::List(Arc::new(Cylinder3D.field("item", false))),
                true,
            ),
            Field::new(
                "spheres",
                DataType::List(Arc::new(Sphere3D.field("item", false))),
                true,
            ),
            Field::new(
                "lines",
                DataType::List(Arc::new(Line3D.field("item", false))),
                true,
            ),
            Field::new(
                "meshes",
                DataType::List(Arc::new(Mesh3D.field("item", false))),
                true,
            ),
            Field::new(
                "text",
                DataType::List(Arc::new(Text3D.field("item", false))),
                true,
            ),
            Field::new(
                "models",
                DataType::List(Arc::new(Model3D.field("item", false))),
                true,
            ),
            Field::new(
                "metadata",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_key_value_storage(),
                    false,
                ))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Deletion of one matching scene entity or all entities.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct SceneEntityDeletion;

impl SpqlType for SceneEntityDeletion {
    const ID: &'static str = "spql.SceneEntityDeletion";
    const NAME: &'static str = "SceneEntityDeletion";
    const ARROW_NAME: &'static str = "spql.SceneEntityDeletion";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("id", DataType::Utf8, true),
            Field::new("all", DataType::Boolean, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Ordered additions, replacements, and deletions for a 3D scene.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct SceneUpdate3D;

impl SpqlType for SceneUpdate3D {
    const ID: &'static str = "spql.SceneUpdate3D";
    const NAME: &'static str = "SceneUpdate3D";
    const ARROW_NAME: &'static str = "spql.SceneUpdate3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "entities",
                DataType::List(Arc::new(SceneEntity3D.field("item", false))),
                true,
            ),
            Field::new(
                "deletions",
                DataType::List(Arc::new(SceneEntityDeletion.field("item", false))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed ellipsoid.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Sphere3D;

impl SpqlType for Sphere3D {
    const ID: &'static str = "spql.Sphere3D";
    const NAME: &'static str = "Sphere3D";
    const ARROW_NAME: &'static str = "spql.Sphere3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Vector3D.field("size", false),
            Color.field("color", true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// A stream selected from one encoded media asset by its structural container index.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct StreamRef;

impl SpqlType for StreamRef {
    const ID: &'static str = "spql.StreamRef";
    const NAME: &'static str = "StreamRef";
    const ARROW_NAME: &'static str = "spql.StreamRef";
    const ALIASES: &'static [&'static str] = &["spql.media.StreamRef"];
    const FAMILY: &'static str = "media";
    const KIND: Kind = Kind::Reference;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Identity,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            EncodedMedia.field("media", true),
            Field::new("stream_index", DataType::Int32, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Styled image-space text annotation.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Text2D;

impl SpqlType for Text2D {
    const ID: &'static str = "spql.Text2D";
    const NAME: &'static str = "Text2D";
    const ARROW_NAME: &'static str = "spql.Text2D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "annotation";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Position2D.field("position", false),
            Field::new("text", DataType::Utf8, false),
            Color.field("color", true),
            Color.field("background_color", true),
            Field::new("font_size", DataType::Float64, true),
            Field::new(
                "metadata",
                DataType::List(Arc::new(Field::new(
                    "item",
                    spql_semantic_key_value_storage(),
                    false,
                ))),
                true,
            ),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Posed three-dimensional text.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Text3D;

impl SpqlType for Text3D {
    const ID: &'static str = "spql.Text3D";
    const NAME: &'static str = "Text3D";
    const ARROW_NAME: &'static str = "spql.Text3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "scene";
    const KIND: Kind = Kind::Archetype;
    const STABILITY: Stability = Stability::Experimental;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Pose3D.field("pose", false),
            Field::new("text", DataType::Utf8, false),
            Color.field("color", true),
            Field::new("font_size", DataType::Float64, true),
            Field::new("billboard", DataType::Boolean, true),
            Field::new("scale_invariant", DataType::Boolean, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Rigid or similarity transform from the child frame to the parent frame.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Transform3D;

impl SpqlType for Transform3D {
    const ID: &'static str = "spql.Transform3D";
    const NAME: &'static str = "Transform3D";
    const ARROW_NAME: &'static str = "spql.Transform3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Vector3D.field("translation", false),
            Quaternion.field("rotation", false),
            Vector3D.field("scale", true),
            Field::new("parent_frame_id", DataType::Utf8, true),
            Field::new("child_frame_id", DataType::Utf8, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Two-dimensional direction or displacement.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Vector2D;

impl SpqlType for Vector2D {
    const ID: &'static str = "spql.Vector2D";
    const NAME: &'static str = "Vector2D";
    const ARROW_NAME: &'static str = "spql.Vector2D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("x", DataType::Float64, false),
            Field::new("y", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Three-dimensional direction or displacement.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Vector3D;

impl SpqlType for Vector3D {
    const ID: &'static str = "spql.Vector3D";
    const NAME: &'static str = "Vector3D";
    const ARROW_NAME: &'static str = "spql.Vector3D";
    const ALIASES: &'static [&'static str] = &[];
    const FAMILY: &'static str = "pose";
    const KIND: Kind = Kind::Component;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::Storage,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new("x", DataType::Float64, false),
            Field::new("y", DataType::Float64, false),
            Field::new("z", DataType::Float64, false),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

/// Decoded planar 8-bit YUV 4:2:0 image with coded and display sizes, per-plane strides and colour
/// metadata. Timing stays on the frame row.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct Yuv420Image;

impl SpqlType for Yuv420Image {
    const ID: &'static str = "spql.Yuv420Image";
    const NAME: &'static str = "Yuv420Image";
    const ARROW_NAME: &'static str = "spql.Yuv420Image";
    const ALIASES: &'static [&'static str] = &["spql.image.Yuv420Image"];
    const FAMILY: &'static str = "image";
    const KIND: Kind = Kind::Decoded;
    const STABILITY: Stability = Stability::Stable;
    const SINCE: &'static str = "1.0";
    const DEPRECATED_BY: Option<&'static str> = None;
    const BRIDGES: Bridges = Bridges {
        order: Bridge::None,
        eq: Bridge::Storage,
    };

    fn storage_type(&self) -> DataType {
        DataType::Struct(Fields::from(vec![
            Field::new(
                "y",
                DataType::List(Arc::new(Field::new("item", DataType::UInt8, false))),
                false,
            ),
            Field::new(
                "u",
                DataType::List(Arc::new(Field::new("item", DataType::UInt8, false))),
                false,
            ),
            Field::new(
                "v",
                DataType::List(Arc::new(Field::new("item", DataType::UInt8, false))),
                false,
            ),
            Field::new("coded_width", DataType::UInt32, false),
            Field::new("coded_height", DataType::UInt32, false),
            Field::new("display_width", DataType::UInt32, false),
            Field::new("display_height", DataType::UInt32, false),
            Field::new("y_stride", DataType::UInt32, false),
            Field::new("u_stride", DataType::UInt32, false),
            Field::new("v_stride", DataType::UInt32, false),
            Field::new("range", DataType::Utf8, true),
            Field::new("matrix", DataType::Utf8, true),
            Field::new("primaries", DataType::Utf8, true),
            Field::new("transfer", DataType::Utf8, true),
        ]))
    }

    fn from_params(_params: &mut ExtensionParams) -> Result<Self, TypeError> {
        Ok(Self)
    }
}

fn spql_media_index_chunk_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("first_sample", DataType::UInt32, false),
        Field::new("offset", DataType::UInt64, false),
    ]))
}

fn spql_media_index_dts_run_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("count", DataType::UInt32, false),
        Field::new("delta", DataType::UInt32, false),
    ]))
}

fn spql_media_index_edit_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("duration", DataType::Int64, false),
        Field::new("media_time", DataType::Int64, false),
        Field::new("rate", DataType::Int32, false),
    ]))
}

fn spql_media_index_gop_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("decode_start", DataType::UInt32, false),
        Field::new("frame_start", DataType::UInt32, false),
        Field::new("pts_start", DataType::Int64, false),
        Field::new("byte_offset", DataType::UInt64, false),
        Field::new("byte_length", DataType::UInt64, false),
        Field::new("sample_count", DataType::UInt32, false),
    ]))
}

fn spql_media_index_media_track_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("track_id", DataType::UInt32, false),
        Field::new("kind", DataType::Utf8, false),
        Field::new("codec", DataType::Utf8, false),
        Field::new("language", DataType::Utf8, true),
        Field::new("width", DataType::UInt32, true),
        Field::new("height", DataType::UInt32, true),
        Field::new("timescale", DataType::UInt32, false),
        Field::new("movie_timescale", DataType::UInt32, false),
        Field::new("duration_ticks", DataType::Int64, false),
        Field::new("sample_entry", DataType::Binary, false),
        Field::new(
            "dts_runs",
            DataType::List(Arc::new(Field::new(
                "item",
                spql_media_index_dts_run_storage(),
                false,
            ))),
            false,
        ),
        Field::new(
            "edit_list",
            DataType::List(Arc::new(Field::new(
                "item",
                spql_media_index_edit_storage(),
                false,
            ))),
            true,
        ),
        Field::new(
            "chunks",
            DataType::List(Arc::new(Field::new(
                "item",
                spql_media_index_chunk_storage(),
                false,
            ))),
            false,
        ),
        Field::new(
            "gops",
            DataType::List(Arc::new(Field::new(
                "item",
                spql_media_index_gop_storage(),
                false,
            ))),
            false,
        ),
        Field::new(
            "sizes",
            DataType::List(Arc::new(Field::new("item", DataType::UInt32, false))),
            false,
        ),
        Field::new(
            "ctts",
            DataType::List(Arc::new(Field::new("item", DataType::Int32, false))),
            true,
        ),
        Field::new(
            "flags",
            DataType::List(Arc::new(Field::new("item", DataType::UInt8, false))),
            false,
        ),
    ]))
}

fn spql_semantic_key_value_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("key", DataType::Utf8, false),
        Field::new("value", DataType::Utf8, false),
    ]))
}

fn spql_semantic_packed_field_storage() -> DataType {
    DataType::Struct(Fields::from(vec![
        Field::new("name", DataType::Utf8, false),
        Field::new("offset", DataType::UInt32, false),
        Field::new("dtype", DataType::Utf8, false),
        Field::new("count", DataType::UInt32, false),
    ]))
}