pymomentum-cpu 0.1.77.post26__cp312-cp312-macosx_15_0_arm64.whl

include/rerun/blueprint/archetypes/view_blueprint.hpp

@@ -0,0 +1,170 @@
+// 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/archetypes/view_blueprint.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/view_class.hpp"
+#include "../../blueprint/components/view_origin.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../components/name.hpp"
+#include "../../components/visible.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: The description of a single view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewBlueprint {
+        /// The class of the view.
+        std::optional<ComponentBatch> class_identifier;
+
+        /// The name of the view.
+        std::optional<ComponentBatch> display_name;
+
+        /// The "anchor point" of this view.
+        ///
+        /// Defaults to the root path '/' if not specified.
+        ///
+        /// The transform at this path forms the reference point for all scene->world transforms in this view.
+        /// I.e. the position of this entity path in space forms the origin of the coordinate system in this view.
+        /// Furthermore, this is the primary indicator for heuristics on what entities we show in this view.
+        std::optional<ComponentBatch> space_origin;
+
+        /// Whether this view is visible.
+        ///
+        /// Defaults to true if not specified.
+        std::optional<ComponentBatch> visible;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.ViewBlueprintIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.blueprint.archetypes.ViewBlueprint";
+
+        /// `ComponentDescriptor` for the `class_identifier` field.
+        static constexpr auto Descriptor_class_identifier = ComponentDescriptor(
+            ArchetypeName, "class_identifier",
+            Loggable<rerun::blueprint::components::ViewClass>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `display_name` field.
+        static constexpr auto Descriptor_display_name = ComponentDescriptor(
+            ArchetypeName, "display_name",
+            Loggable<rerun::components::Name>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `space_origin` field.
+        static constexpr auto Descriptor_space_origin = ComponentDescriptor(
+            ArchetypeName, "space_origin",
+            Loggable<rerun::blueprint::components::ViewOrigin>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `visible` field.
+        static constexpr auto Descriptor_visible = ComponentDescriptor(
+            ArchetypeName, "visible",
+            Loggable<rerun::components::Visible>::Descriptor.component_name
+        );
+
+      public:
+        ViewBlueprint() = default;
+        ViewBlueprint(ViewBlueprint&& other) = default;
+        ViewBlueprint(const ViewBlueprint& other) = default;
+        ViewBlueprint& operator=(const ViewBlueprint& other) = default;
+        ViewBlueprint& operator=(ViewBlueprint&& other) = default;
+
+        explicit ViewBlueprint(rerun::blueprint::components::ViewClass _class_identifier)
+            : class_identifier(ComponentBatch::from_loggable(
+                                   std::move(_class_identifier), Descriptor_class_identifier
+              )
+                                   .value_or_throw()) {}
+
+        /// Update only some specific fields of a `ViewBlueprint`.
+        static ViewBlueprint update_fields() {
+            return ViewBlueprint();
+        }
+
+        /// Clear all the fields of a `ViewBlueprint`.
+        static ViewBlueprint clear_fields();
+
+        /// The class of the view.
+        ViewBlueprint with_class_identifier(
+            const rerun::blueprint::components::ViewClass& _class_identifier
+        ) && {
+            class_identifier =
+                ComponentBatch::from_loggable(_class_identifier, Descriptor_class_identifier)
+                    .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The name of the view.
+        ViewBlueprint with_display_name(const rerun::components::Name& _display_name) && {
+            display_name = ComponentBatch::from_loggable(_display_name, Descriptor_display_name)
+                               .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The "anchor point" of this view.
+        ///
+        /// Defaults to the root path '/' if not specified.
+        ///
+        /// The transform at this path forms the reference point for all scene->world transforms in this view.
+        /// I.e. the position of this entity path in space forms the origin of the coordinate system in this view.
+        /// Furthermore, this is the primary indicator for heuristics on what entities we show in this view.
+        ViewBlueprint with_space_origin(
+            const rerun::blueprint::components::ViewOrigin& _space_origin
+        ) && {
+            space_origin = ComponentBatch::from_loggable(_space_origin, Descriptor_space_origin)
+                               .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Whether this view is visible.
+        ///
+        /// Defaults to true if not specified.
+        ViewBlueprint with_visible(const rerun::components::Visible& _visible) && {
+            visible = ComponentBatch::from_loggable(_visible, Descriptor_visible).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::ViewBlueprint> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::ViewBlueprint& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/view_contents.hpp

@@ -0,0 +1,142 @@
+// 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/archetypes/view_contents.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/query_expression.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: The contents of a `View`.
+    ///
+    /// The contents are found by combining a collection of `QueryExpression`s.
+    ///
+    /// ```diff
+    /// + /world/**           # add everything…
+    /// - /world/roads/**     # …but remove all roads…
+    /// + /world/roads/main   # …but show main road
+    /// ```
+    ///
+    /// If there is multiple matching rules, the most specific rule wins.
+    /// If there are multiple rules of the same specificity, the last one wins.
+    /// If no rules match, the path is excluded.
+    ///
+    /// Specifying a path without a `+` or `-` prefix is equivalent to `+`:
+    /// ```diff
+    /// /world/**           # add everything…
+    /// - /world/roads/**   # …but remove all roads…
+    /// /world/roads/main   # …but show main road
+    /// ```
+    ///
+    /// The `/**` suffix matches the whole subtree, i.e. self and any child, recursively
+    /// (`/world/**` matches both `/world` and `/world/car/driver`).
+    /// Other uses of `*` are not (yet) supported.
+    ///
+    /// Internally, `EntityPathFilter` sorts the rule by entity path, with recursive coming before non-recursive.
+    /// This means the last matching rule is also the most specific one. For instance:
+    /// ```diff
+    /// + /world/**
+    /// - /world
+    /// - /world/car/**
+    /// + /world/car/driver
+    /// ```
+    ///
+    /// The last rule matching `/world/car/driver` is `+ /world/car/driver`, so it is included.
+    /// The last rule matching `/world/car/hood` is `- /world/car/**`, so it is excluded.
+    /// The last rule matching `/world` is `- /world`, so it is excluded.
+    /// The last rule matching `/world/house` is `+ /world/**`, so it is included.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewContents {
+        /// The `QueryExpression` that populates the contents for the view.
+        ///
+        /// They determine which entities are part of the view.
+        std::optional<ComponentBatch> query;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.ViewContentsIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.blueprint.archetypes.ViewContents";
+
+        /// `ComponentDescriptor` for the `query` field.
+        static constexpr auto Descriptor_query = ComponentDescriptor(
+            ArchetypeName, "query",
+            Loggable<rerun::blueprint::components::QueryExpression>::Descriptor.component_name
+        );
+
+      public:
+        ViewContents() = default;
+        ViewContents(ViewContents&& other) = default;
+        ViewContents(const ViewContents& other) = default;
+        ViewContents& operator=(const ViewContents& other) = default;
+        ViewContents& operator=(ViewContents&& other) = default;
+
+        explicit ViewContents(Collection<rerun::blueprint::components::QueryExpression> _query)
+            : query(ComponentBatch::from_loggable(std::move(_query), Descriptor_query)
+                        .value_or_throw()) {}
+
+        /// Update only some specific fields of a `ViewContents`.
+        static ViewContents update_fields() {
+            return ViewContents();
+        }
+
+        /// Clear all the fields of a `ViewContents`.
+        static ViewContents clear_fields();
+
+        /// The `QueryExpression` that populates the contents for the view.
+        ///
+        /// They determine which entities are part of the view.
+        ViewContents with_query(
+            const Collection<rerun::blueprint::components::QueryExpression>& _query
+        ) && {
+            query = ComponentBatch::from_loggable(_query, Descriptor_query).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::ViewContents> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::ViewContents& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/viewport_blueprint.hpp

@@ -0,0 +1,200 @@
+// 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/archetypes/viewport_blueprint.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/auto_layout.hpp"
+#include "../../blueprint/components/auto_views.hpp"
+#include "../../blueprint/components/root_container.hpp"
+#include "../../blueprint/components/view_maximized.hpp"
+#include "../../blueprint/components/viewer_recommendation_hash.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: The top-level description of the viewport.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewportBlueprint {
+        /// The layout of the views
+        std::optional<ComponentBatch> root_container;
+
+        /// Show one tab as maximized?
+        std::optional<ComponentBatch> maximized;
+
+        /// Whether the viewport layout is determined automatically.
+        ///
+        /// If `true`, the container layout will be reset whenever a new view is added or removed.
+        /// This defaults to `false` and is automatically set to `false` when there is user determined layout.
+        std::optional<ComponentBatch> auto_layout;
+
+        /// Whether or not views should be created automatically.
+        ///
+        /// If `true`, the viewer will only add views that it hasn't considered previously (as identified by `past_viewer_recommendations`)
+        /// and which aren't deemed redundant to existing views.
+        /// This defaults to `false` and is automatically set to `false` when the user adds views manually in the viewer.
+        std::optional<ComponentBatch> auto_views;
+
+        /// Hashes of all recommended views the viewer has already added and that should not be added again.
+        ///
+        /// This is an internal field and should not be set usually.
+        /// If you want the viewer from stopping to add views, you should set `auto_views` to `false`.
+        ///
+        /// The viewer uses this to determine whether it should keep adding views.
+        std::optional<ComponentBatch> past_viewer_recommendations;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.ViewportBlueprintIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] =
+            "rerun.blueprint.archetypes.ViewportBlueprint";
+
+        /// `ComponentDescriptor` for the `root_container` field.
+        static constexpr auto Descriptor_root_container = ComponentDescriptor(
+            ArchetypeName, "root_container",
+            Loggable<rerun::blueprint::components::RootContainer>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `maximized` field.
+        static constexpr auto Descriptor_maximized = ComponentDescriptor(
+            ArchetypeName, "maximized",
+            Loggable<rerun::blueprint::components::ViewMaximized>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `auto_layout` field.
+        static constexpr auto Descriptor_auto_layout = ComponentDescriptor(
+            ArchetypeName, "auto_layout",
+            Loggable<rerun::blueprint::components::AutoLayout>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `auto_views` field.
+        static constexpr auto Descriptor_auto_views = ComponentDescriptor(
+            ArchetypeName, "auto_views",
+            Loggable<rerun::blueprint::components::AutoViews>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `past_viewer_recommendations` field.
+        static constexpr auto Descriptor_past_viewer_recommendations = ComponentDescriptor(
+            ArchetypeName, "past_viewer_recommendations",
+            Loggable<rerun::blueprint::components::ViewerRecommendationHash>::Descriptor
+                .component_name
+        );
+
+      public:
+        ViewportBlueprint() = default;
+        ViewportBlueprint(ViewportBlueprint&& other) = default;
+        ViewportBlueprint(const ViewportBlueprint& other) = default;
+        ViewportBlueprint& operator=(const ViewportBlueprint& other) = default;
+        ViewportBlueprint& operator=(ViewportBlueprint&& other) = default;
+
+        /// Update only some specific fields of a `ViewportBlueprint`.
+        static ViewportBlueprint update_fields() {
+            return ViewportBlueprint();
+        }
+
+        /// Clear all the fields of a `ViewportBlueprint`.
+        static ViewportBlueprint clear_fields();
+
+        /// The layout of the views
+        ViewportBlueprint with_root_container(
+            const rerun::blueprint::components::RootContainer& _root_container
+        ) && {
+            root_container =
+                ComponentBatch::from_loggable(_root_container, Descriptor_root_container)
+                    .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Show one tab as maximized?
+        ViewportBlueprint with_maximized(
+            const rerun::blueprint::components::ViewMaximized& _maximized
+        ) && {
+            maximized =
+                ComponentBatch::from_loggable(_maximized, Descriptor_maximized).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Whether the viewport layout is determined automatically.
+        ///
+        /// If `true`, the container layout will be reset whenever a new view is added or removed.
+        /// This defaults to `false` and is automatically set to `false` when there is user determined layout.
+        ViewportBlueprint with_auto_layout(
+            const rerun::blueprint::components::AutoLayout& _auto_layout
+        ) && {
+            auto_layout = ComponentBatch::from_loggable(_auto_layout, Descriptor_auto_layout)
+                              .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Whether or not views should be created automatically.
+        ///
+        /// If `true`, the viewer will only add views that it hasn't considered previously (as identified by `past_viewer_recommendations`)
+        /// and which aren't deemed redundant to existing views.
+        /// This defaults to `false` and is automatically set to `false` when the user adds views manually in the viewer.
+        ViewportBlueprint with_auto_views(const rerun::blueprint::components::AutoViews& _auto_views
+        ) && {
+            auto_views =
+                ComponentBatch::from_loggable(_auto_views, Descriptor_auto_views).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Hashes of all recommended views the viewer has already added and that should not be added again.
+        ///
+        /// This is an internal field and should not be set usually.
+        /// If you want the viewer from stopping to add views, you should set `auto_views` to `false`.
+        ///
+        /// The viewer uses this to determine whether it should keep adding views.
+        ViewportBlueprint with_past_viewer_recommendations(
+            const Collection<rerun::blueprint::components::ViewerRecommendationHash>&
+                _past_viewer_recommendations
+        ) && {
+            past_viewer_recommendations = ComponentBatch::from_loggable(
+                                              _past_viewer_recommendations,
+                                              Descriptor_past_viewer_recommendations
+            )
+                                              .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::ViewportBlueprint> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::ViewportBlueprint& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/visible_time_ranges.hpp

@@ -0,0 +1,116 @@
+// 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/archetypes/visible_time_ranges.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/visible_time_range.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: Configures what range of each timeline is shown on a view.
+    ///
+    /// Whenever no visual time range applies, queries are done with "latest-at" semantics.
+    /// This means that the view will, starting from the time cursor position,
+    /// query the latest data available for each component type.
+    ///
+    /// The default visual time range depends on the type of view this property applies to:
+    /// - For time series views, the default is to show the entire timeline.
+    /// - For any other view, the default is to apply latest-at semantics.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct VisibleTimeRanges {
+        /// The time ranges to show for each timeline unless specified otherwise on a per-entity basis.
+        ///
+        /// If a timeline is specified more than once, the first entry will be used.
+        std::optional<ComponentBatch> ranges;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.VisibleTimeRangesIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] =
+            "rerun.blueprint.archetypes.VisibleTimeRanges";
+
+        /// `ComponentDescriptor` for the `ranges` field.
+        static constexpr auto Descriptor_ranges = ComponentDescriptor(
+            ArchetypeName, "ranges",
+            Loggable<rerun::blueprint::components::VisibleTimeRange>::Descriptor.component_name
+        );
+
+      public:
+        VisibleTimeRanges() = default;
+        VisibleTimeRanges(VisibleTimeRanges&& other) = default;
+        VisibleTimeRanges(const VisibleTimeRanges& other) = default;
+        VisibleTimeRanges& operator=(const VisibleTimeRanges& other) = default;
+        VisibleTimeRanges& operator=(VisibleTimeRanges&& other) = default;
+
+        explicit VisibleTimeRanges(
+            Collection<rerun::blueprint::components::VisibleTimeRange> _ranges
+        )
+            : ranges(ComponentBatch::from_loggable(std::move(_ranges), Descriptor_ranges)
+                         .value_or_throw()) {}
+
+        /// Update only some specific fields of a `VisibleTimeRanges`.
+        static VisibleTimeRanges update_fields() {
+            return VisibleTimeRanges();
+        }
+
+        /// Clear all the fields of a `VisibleTimeRanges`.
+        static VisibleTimeRanges clear_fields();
+
+        /// The time ranges to show for each timeline unless specified otherwise on a per-entity basis.
+        ///
+        /// If a timeline is specified more than once, the first entry will be used.
+        VisibleTimeRanges with_ranges(
+            const Collection<rerun::blueprint::components::VisibleTimeRange>& _ranges
+        ) && {
+            ranges = ComponentBatch::from_loggable(_ranges, Descriptor_ranges).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::VisibleTimeRanges> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::VisibleTimeRanges& archetype
+        );
+    };
+} // namespace rerun