pymomentum-cpu 0.1.77.post30__cp313-cp313-manylinux_2_39_x86_64.whl

include/rerun/blueprint/components/view_maximized.hpp

@@ -0,0 +1,79 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/view_maximized.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/uuid.hpp"
+#include "../../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Whether a view is maximized.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewMaximized {
+        rerun::datatypes::Uuid view_id;
+
+      public:
+        ViewMaximized() = default;
+
+        ViewMaximized(rerun::datatypes::Uuid view_id_) : view_id(view_id_) {}
+
+        ViewMaximized& operator=(rerun::datatypes::Uuid view_id_) {
+            view_id = view_id_;
+            return *this;
+        }
+
+        ViewMaximized(std::array<uint8_t, 16> bytes_) : view_id(bytes_) {}
+
+        ViewMaximized& operator=(std::array<uint8_t, 16> bytes_) {
+            view_id = bytes_;
+            return *this;
+        }
+
+        /// Cast to the underlying Uuid datatype
+        operator rerun::datatypes::Uuid() const {
+            return view_id;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Uuid) == sizeof(blueprint::components::ViewMaximized));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ViewMaximized> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ViewMaximized";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Uuid>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ViewMaximized` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ViewMaximized* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Uuid>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Uuid>::to_arrow(
+                    &instances->view_id,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/view_origin.hpp

@@ -0,0 +1,81 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/view_origin.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/entity_path.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The origin of a view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewOrigin {
+        rerun::datatypes::EntityPath value;
+
+      public:
+        ViewOrigin() = default;
+
+        ViewOrigin(rerun::datatypes::EntityPath value_) : value(std::move(value_)) {}
+
+        ViewOrigin& operator=(rerun::datatypes::EntityPath value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        ViewOrigin(std::string path_) : value(std::move(path_)) {}
+
+        ViewOrigin& operator=(std::string path_) {
+            value = std::move(path_);
+            return *this;
+        }
+
+        /// Cast to the underlying EntityPath datatype
+        operator rerun::datatypes::EntityPath() const {
+            return value;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::EntityPath) == sizeof(blueprint::components::ViewOrigin)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ViewOrigin> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.ViewOrigin";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::EntityPath>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ViewOrigin` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ViewOrigin* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::EntityPath>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::EntityPath>::to_arrow(
+                    &instances->value,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/viewer_recommendation_hash.hpp

@@ -0,0 +1,82 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/viewer_recommendation_hash.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/uint64.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Hash of a viewer recommendation.
+    ///
+    /// The formation of this hash is considered an internal implementation detail of the viewer.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewerRecommendationHash {
+        rerun::datatypes::UInt64 value;
+
+      public:
+        ViewerRecommendationHash() = default;
+
+        ViewerRecommendationHash(rerun::datatypes::UInt64 value_) : value(value_) {}
+
+        ViewerRecommendationHash& operator=(rerun::datatypes::UInt64 value_) {
+            value = value_;
+            return *this;
+        }
+
+        ViewerRecommendationHash(uint64_t value_) : value(value_) {}
+
+        ViewerRecommendationHash& operator=(uint64_t value_) {
+            value = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying UInt64 datatype
+        operator rerun::datatypes::UInt64() const {
+            return value;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::UInt64) == sizeof(blueprint::components::ViewerRecommendationHash)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ViewerRecommendationHash> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ViewerRecommendationHash";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::UInt64>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ViewerRecommendationHash` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ViewerRecommendationHash* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::UInt64>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::UInt64>::to_arrow(
+                    &instances->value,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/visible_time_range.hpp

@@ -0,0 +1,77 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/visible_time_range.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/visible_time_range.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The range of values on a given timeline that will be included in a view's query.
+    ///
+    /// Refer to `VisibleTimeRanges` archetype for more information.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct VisibleTimeRange {
+        rerun::datatypes::VisibleTimeRange value;
+
+      public:
+        VisibleTimeRange() = default;
+
+        VisibleTimeRange(rerun::datatypes::VisibleTimeRange value_) : value(std::move(value_)) {}
+
+        VisibleTimeRange& operator=(rerun::datatypes::VisibleTimeRange value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying VisibleTimeRange datatype
+        operator rerun::datatypes::VisibleTimeRange() const {
+            return value;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::VisibleTimeRange) ==
+        sizeof(blueprint::components::VisibleTimeRange)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::VisibleTimeRange> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.VisibleTimeRange";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::VisibleTimeRange>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::VisibleTimeRange` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::VisibleTimeRange* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::VisibleTimeRange>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::VisibleTimeRange>::to_arrow(
+                    &instances->value,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/visual_bounds2d.hpp

@@ -0,0 +1,74 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/visual_bounds2d.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/range2d.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Visual bounds in 2D space used for `Spatial2DView`.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct VisualBounds2D {
+        /// X and y ranges that should be visible.
+        rerun::datatypes::Range2D range2d;
+
+      public:
+        VisualBounds2D() = default;
+
+        VisualBounds2D(rerun::datatypes::Range2D range2d_) : range2d(range2d_) {}
+
+        VisualBounds2D& operator=(rerun::datatypes::Range2D range2d_) {
+            range2d = range2d_;
+            return *this;
+        }
+
+        /// Cast to the underlying Range2D datatype
+        operator rerun::datatypes::Range2D() const {
+            return range2d;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::Range2D) == sizeof(blueprint::components::VisualBounds2D)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::VisualBounds2D> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.VisualBounds2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Range2D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::VisualBounds2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::VisualBounds2D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Range2D>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Range2D>::to_arrow(
+                    &instances->range2d,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/visualizer_override.hpp

@@ -0,0 +1,86 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/visualizer_overrides.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/utf8.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Single visualizer override the visualizers for an entity.
+    ///
+    /// For details see `archetypes::VisualizerOverrides`.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct VisualizerOverride {
+        /// Names of a visualizer that should be active.
+        rerun::datatypes::Utf8 visualizer;
+
+      public:
+        VisualizerOverride() = default;
+
+        VisualizerOverride(rerun::datatypes::Utf8 visualizer_)
+            : visualizer(std::move(visualizer_)) {}
+
+        VisualizerOverride& operator=(rerun::datatypes::Utf8 visualizer_) {
+            visualizer = std::move(visualizer_);
+            return *this;
+        }
+
+        VisualizerOverride(std::string value_) : visualizer(std::move(value_)) {}
+
+        VisualizerOverride& operator=(std::string value_) {
+            visualizer = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return visualizer;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::Utf8) == sizeof(blueprint::components::VisualizerOverride)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::VisualizerOverride> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.VisualizerOverride";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::VisualizerOverride` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::VisualizerOverride* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Utf8>::to_arrow(
+                    &instances->visualizer,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/zoom_level.hpp

@@ -0,0 +1,78 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/components/zoom_level.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float64.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: A zoom level determines how much of the world is visible on a map.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ZoomLevel {
+        /// Zoom level: 0 being the lowest zoom level (fully zoomed out) and 22 being the highest (fully zoomed in).
+        rerun::datatypes::Float64 zoom;
+
+      public:
+        ZoomLevel() = default;
+
+        ZoomLevel(rerun::datatypes::Float64 zoom_) : zoom(zoom_) {}
+
+        ZoomLevel& operator=(rerun::datatypes::Float64 zoom_) {
+            zoom = zoom_;
+            return *this;
+        }
+
+        ZoomLevel(double value_) : zoom(value_) {}
+
+        ZoomLevel& operator=(double value_) {
+            zoom = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float64 datatype
+        operator rerun::datatypes::Float64() const {
+            return zoom;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float64) == sizeof(blueprint::components::ZoomLevel));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ZoomLevel> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.ZoomLevel";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Float64>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ZoomLevel` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ZoomLevel* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Float64>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Float64>::to_arrow(
+                    &instances->zoom,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components.hpp

@@ -0,0 +1,41 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+
+#pragma once
+
+#include "blueprint/components/active_tab.hpp"
+#include "blueprint/components/apply_latest_at.hpp"
+#include "blueprint/components/auto_layout.hpp"
+#include "blueprint/components/auto_views.hpp"
+#include "blueprint/components/background_kind.hpp"
+#include "blueprint/components/column_share.hpp"
+#include "blueprint/components/component_column_selector.hpp"
+#include "blueprint/components/container_kind.hpp"
+#include "blueprint/components/corner2d.hpp"
+#include "blueprint/components/enabled.hpp"
+#include "blueprint/components/filter_by_range.hpp"
+#include "blueprint/components/filter_is_not_null.hpp"
+#include "blueprint/components/force_distance.hpp"
+#include "blueprint/components/force_iterations.hpp"
+#include "blueprint/components/force_strength.hpp"
+#include "blueprint/components/grid_columns.hpp"
+#include "blueprint/components/grid_spacing.hpp"
+#include "blueprint/components/included_content.hpp"
+#include "blueprint/components/lock_range_during_zoom.hpp"
+#include "blueprint/components/map_provider.hpp"
+#include "blueprint/components/near_clip_plane.hpp"
+#include "blueprint/components/panel_state.hpp"
+#include "blueprint/components/query_expression.hpp"
+#include "blueprint/components/root_container.hpp"
+#include "blueprint/components/row_share.hpp"
+#include "blueprint/components/selected_columns.hpp"
+#include "blueprint/components/tensor_dimension_index_slider.hpp"
+#include "blueprint/components/timeline_name.hpp"
+#include "blueprint/components/view_class.hpp"
+#include "blueprint/components/view_fit.hpp"
+#include "blueprint/components/view_maximized.hpp"
+#include "blueprint/components/view_origin.hpp"
+#include "blueprint/components/viewer_recommendation_hash.hpp"
+#include "blueprint/components/visible_time_range.hpp"
+#include "blueprint/components/visual_bounds2d.hpp"
+#include "blueprint/components/visualizer_override.hpp"
+#include "blueprint/components/zoom_level.hpp"

include/rerun/blueprint/datatypes/component_column_selector.hpp

@@ -0,0 +1,61 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/datatypes/component_column_selector.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/entity_path.hpp"
+#include "../../datatypes/utf8.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::blueprint::datatypes {
+    /// **Datatype**: Describe a component column to be selected in the dataframe view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ComponentColumnSelector {
+        /// The entity path for this component.
+        rerun::datatypes::EntityPath entity_path;
+
+        /// The name of the component.
+        rerun::datatypes::Utf8 component;
+
+      public:
+        ComponentColumnSelector() = default;
+    };
+} // namespace rerun::blueprint::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::datatypes::ComponentColumnSelector> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.datatypes.ComponentColumnSelector";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::blueprint:: datatypes::ComponentColumnSelector` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::datatypes::ComponentColumnSelector* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder,
+            const blueprint::datatypes::ComponentColumnSelector* elements, size_t num_elements
+        );
+    };
+} // namespace rerun