diff --git a/src/PrusaSlicer.cpp b/src/PrusaSlicer.cpp
index 6de4b9c1cb..e668703710 100644
--- a/src/PrusaSlicer.cpp
+++ b/src/PrusaSlicer.cpp
@@ -63,6 +63,7 @@
 #include "libslic3r/BlacklistedLibraryCheck.hpp"
 #include "libslic3r/ProfilesSharingUtils.hpp"
 #include "libslic3r/Utils/DirectoriesUtils.hpp"
+#include "libslic3r/MultipleBeds.hpp"
 
 #include "PrusaSlicer.hpp"
 
@@ -389,7 +390,7 @@ int CLI::run(int argc, char **argv)
     // Loop through transform options.
     bool user_center_specified = false;
 
-    const BedsGrid::Gap gap{s_multiple_beds.get_bed_gap()};
+    const Vec2crd gap{s_multiple_beds.get_bed_gap()};
     arr2::ArrangeBed bed = arr2::to_arrange_bed(get_bed_shape(m_print_config), gap);
     arr2::ArrangeSettings arrange_cfg;
     arrange_cfg.set_distance_from_objects(min_object_distance(m_print_config));
diff --git a/src/libslic3r/MultipleBeds.cpp b/src/libslic3r/MultipleBeds.cpp
index f617b7715a..a512c9c000 100644
--- a/src/libslic3r/MultipleBeds.cpp
+++ b/src/libslic3r/MultipleBeds.cpp
@@ -283,7 +283,7 @@ bool MultipleBeds::update_after_load_or_arrange(Model& model, const BuildVolume&
 }
 
 
-BedsGrid::Gap MultipleBeds::get_bed_gap() const {
+Vec2crd MultipleBeds::get_bed_gap() const {
     const Vec2d size_with_gap{
         m_build_volume_bb_incl_model.size().cwiseProduct(
             Vec2d::Ones() + Vec2d{bed_gap_x, bed_gap_y})};
diff --git a/src/libslic3r/MultipleBeds.hpp b/src/libslic3r/MultipleBeds.hpp
index 3a6c32ba43..1b9f1ee4a6 100644
--- a/src/libslic3r/MultipleBeds.hpp
+++ b/src/libslic3r/MultipleBeds.hpp
@@ -20,7 +20,6 @@ extern bool s_beds_just_switched;
 namespace BedsGrid {
 using GridCoords = Vec2crd;
 using Index = int;
-using Gap = Vec2crd;
 Index grid_coords2index(const GridCoords &coords);
 GridCoords index2grid_coords(Index index);
 }
@@ -62,7 +61,7 @@ public:
         m_build_volume_bb = build_volume_bb;
         m_build_volume_bb_incl_model = build_volume_bb_incl_model;
     }
-    BedsGrid::Gap get_bed_gap() const;
+    Vec2crd get_bed_gap() const;
 	void   ensure_wipe_towers_on_beds(Model& model, const std::vector<std::unique_ptr<Print>>& prints);
 
 private:
diff --git a/src/slic3r-arrange-wrapper/include/arrange-wrapper/Scene.hpp b/src/slic3r-arrange-wrapper/include/arrange-wrapper/Scene.hpp
index a3aa94f498..aad50f681b 100644
--- a/src/slic3r-arrange-wrapper/include/arrange-wrapper/Scene.hpp
+++ b/src/slic3r-arrange-wrapper/include/arrange-wrapper/Scene.hpp
@@ -194,9 +194,9 @@ inline BoundingBox bounding_box(const ExtendedBed &bed)
     return bedbb;
 }
 
-inline BedsGrid::Gap bed_gap(const ExtendedBed &bed)
+inline Vec2crd bed_gap(const ExtendedBed &bed)
 {
-    BedsGrid::Gap gap;
+    Vec2crd gap;
     visit_bed([&gap](auto &rawbed) { gap = bed_gap(rawbed); }, bed);
 
     return gap;
@@ -250,7 +250,7 @@ public:
         return std::move(static_cast<Subclass&>(*this));
     }
 
-    Subclass &&set_bed(const Points &pts, const BedsGrid::Gap &gap)
+    Subclass &&set_bed(const Points &pts, const Vec2crd &gap)
     {
         m_bed = arr2::to_arrange_bed(pts, gap);
         return std::move(static_cast<Subclass&>(*this));
diff --git a/src/slic3r-arrange-wrapper/include/arrange-wrapper/SceneBuilder.hpp b/src/slic3r-arrange-wrapper/include/arrange-wrapper/SceneBuilder.hpp
index 0e962b62b6..2ce6227e3d 100644
--- a/src/slic3r-arrange-wrapper/include/arrange-wrapper/SceneBuilder.hpp
+++ b/src/slic3r-arrange-wrapper/include/arrange-wrapper/SceneBuilder.hpp
@@ -273,8 +273,8 @@ public:
 
     using SceneBuilderBase<SceneBuilder>::set_bed;
 
-    SceneBuilder &&set_bed(const DynamicPrintConfig &cfg, const BedsGrid::Gap &gap);
-    SceneBuilder &&set_bed(const Print &print, const BedsGrid::Gap &gap);
+    SceneBuilder &&set_bed(const DynamicPrintConfig &cfg, const Vec2crd &gap);
+    SceneBuilder &&set_bed(const Print &print, const Vec2crd &gap);
 
     SceneBuilder && set_wipe_tower_handlers(std::vector<AnyPtr<WipeTowerHandler>> &&handlers)
     {
@@ -379,7 +379,7 @@ class GridStriderVBedHandler: public VirtualBedHandler
     YStriderVBedHandler m_ystrider;
 
 public:
-    GridStriderVBedHandler(const BoundingBox &bedbb, const BedsGrid::Gap &gap)
+    GridStriderVBedHandler(const BoundingBox &bedbb, const Vec2crd &gap)
         : m_xstrider{bedbb, gap.x()}
         , m_ystrider{bedbb, gap.y()}
     {}
diff --git a/src/slic3r-arrange-wrapper/include/arrange-wrapper/SegmentedRectangleBed.hpp b/src/slic3r-arrange-wrapper/include/arrange-wrapper/SegmentedRectangleBed.hpp
index bdb9e297e6..865fb5a8bc 100644
--- a/src/slic3r-arrange-wrapper/include/arrange-wrapper/SegmentedRectangleBed.hpp
+++ b/src/slic3r-arrange-wrapper/include/arrange-wrapper/SegmentedRectangleBed.hpp
@@ -20,14 +20,14 @@ template<class SegX = void, class SegY = void, class Pivot = void>
 struct SegmentedRectangleBed {
     Vec<2, size_t> segments = Vec<2, size_t>::Ones();
     BoundingBox bb;
-    BedsGrid::Gap gap;
+    Vec2crd gap;
     RectPivots pivot = RectPivots::Center;
 
     SegmentedRectangleBed() = default;
     SegmentedRectangleBed(const BoundingBox &bb,
                           size_t segments_x,
                           size_t segments_y,
-                          const BedsGrid::Gap &gap,
+                          const Vec2crd &gap,
                           const RectPivots pivot = RectPivots::Center)
         : segments{segments_x, segments_y}, bb{bb}, gap{gap}, pivot{pivot}
     {}
@@ -43,13 +43,13 @@ struct SegmentedRectangleBed<std::integral_constant<size_t, SegX>,
                              std::integral_constant<size_t, SegY>>
 {
     BoundingBox bb;
-    BedsGrid::Gap gap;
+    Vec2crd gap;
     RectPivots pivot = RectPivots::Center;
 
     SegmentedRectangleBed() = default;
 
     explicit SegmentedRectangleBed(const BoundingBox &b,
-                                   const BedsGrid::Gap &gap,
+                                   const Vec2crd &gap,
                                    const RectPivots pivot = RectPivots::Center)
         : bb{b},
           gap{gap}
@@ -67,11 +67,11 @@ struct SegmentedRectangleBed<std::integral_constant<size_t, SegX>,
                              std::integral_constant<RectPivots, pivot>>
 {
     BoundingBox bb;
-    BedsGrid::Gap gap;
+    Vec2crd gap;
 
     SegmentedRectangleBed() = default;
 
-    explicit SegmentedRectangleBed(const BoundingBox &b, const BedsGrid::Gap &gap) : bb{b}, gap{gap} {}
+    explicit SegmentedRectangleBed(const BoundingBox &b, const Vec2crd &gap) : bb{b}, gap{gap} {}
 
     size_t segments_x() const noexcept { return SegX; }
     size_t segments_y() const noexcept { return SegY; }
diff --git a/src/slic3r-arrange-wrapper/src/SceneBuilder.cpp b/src/slic3r-arrange-wrapper/src/SceneBuilder.cpp
index 2d25cf6a68..abf495471e 100644
--- a/src/slic3r-arrange-wrapper/src/SceneBuilder.cpp
+++ b/src/slic3r-arrange-wrapper/src/SceneBuilder.cpp
@@ -191,7 +191,7 @@ void SceneBuilder::build_scene(Scene &sc) &&
 
     if (m_fff_print && !m_sla_print) {
         if (is_infinite_bed(m_bed)) {
-            set_bed(*m_fff_print, BedsGrid::Gap::Zero());
+            set_bed(*m_fff_print, Vec2crd::Zero());
         } else {
             set_brim_and_skirt();
         }
@@ -446,7 +446,7 @@ SceneBuilder &&SceneBuilder::set_sla_print(AnyPtr<const SLAPrint> mdl_print)
     return std::move(*this);
 }
 
-SceneBuilder &&SceneBuilder::set_bed(const DynamicPrintConfig &cfg, const BedsGrid::Gap &gap)
+SceneBuilder &&SceneBuilder::set_bed(const DynamicPrintConfig &cfg, const Vec2crd &gap)
 {
     Points bedpts = get_bed_shape(cfg);
 
@@ -459,7 +459,7 @@ SceneBuilder &&SceneBuilder::set_bed(const DynamicPrintConfig &cfg, const BedsGr
     return std::move(*this);
 }
 
-SceneBuilder &&SceneBuilder::set_bed(const Print &print, const BedsGrid::Gap &gap)
+SceneBuilder &&SceneBuilder::set_bed(const Print &print, const Vec2crd &gap)
 {
     Points bedpts = get_bed_shape(print.config());
 
@@ -940,7 +940,7 @@ std::unique_ptr<VirtualBedHandler> VirtualBedHandler::create(const ExtendedBed &
     if (is_infinite_bed(bed)) {
         ret = std::make_unique<PhysicalOnlyVBedHandler>();
     } else {
-        BedsGrid::Gap gap;
+        Vec2crd gap;
         visit_bed([&gap](auto &rawbed) { gap = bed_gap(rawbed); }, bed);
         BoundingBox bedbb;
         visit_bed([&bedbb](auto &rawbed) { bedbb = bounding_box(rawbed); }, bed);
diff --git a/src/slic3r-arrange/include/arrange/Beds.hpp b/src/slic3r-arrange/include/arrange/Beds.hpp
index d6e4ed9588..aa86c91467 100644
--- a/src/slic3r-arrange/include/arrange/Beds.hpp
+++ b/src/slic3r-arrange/include/arrange/Beds.hpp
@@ -16,7 +16,6 @@
 #include <limits>
 #include <type_traits>
 
-#include "libslic3r/MultipleBeds.hpp"
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/libslic3r.h"
 
@@ -36,17 +35,17 @@ struct InfiniteBed {
 BoundingBox bounding_box(const InfiniteBed &bed);
 
 inline InfiniteBed offset(const InfiniteBed &bed, coord_t) { return bed; }
-inline BedsGrid::Gap bed_gap(const InfiniteBed &)
+inline Vec2crd bed_gap(const InfiniteBed &)
 {
-    return BedsGrid::Gap::Zero();
+    return Vec2crd::Zero();
 }
 
 struct RectangleBed {
     BoundingBox bb;
-    BedsGrid::Gap gap;
+    Vec2crd gap;
 
-    explicit RectangleBed(const BoundingBox &bedbb, const BedsGrid::Gap &gap) : bb{bedbb}, gap{gap} {}
-    explicit RectangleBed(coord_t w, coord_t h, const BedsGrid::Gap &gap = BedsGrid::Gap::Zero(), Point c = {0, 0}):
+    explicit RectangleBed(const BoundingBox &bedbb, const Vec2crd &gap) : bb{bedbb}, gap{gap} {}
+    explicit RectangleBed(coord_t w, coord_t h, const Vec2crd &gap = Vec2crd::Zero(), Point c = {0, 0}):
         bb{{c.x() - w / 2, c.y() - h / 2}, {c.x() + w / 2, c.y() + h / 2}}, gap{gap}
     {}
 
@@ -60,7 +59,7 @@ inline RectangleBed offset(RectangleBed bed, coord_t v)
     bed.bb.offset(v);
     return bed;
 }
-inline BedsGrid::Gap bed_gap(const RectangleBed &bed) {
+inline Vec2crd bed_gap(const RectangleBed &bed) {
     return bed.gap;
 }
 
@@ -74,11 +73,11 @@ inline Polygon to_rectangle(const RectangleBed &bed)
 class CircleBed {
     Point  m_center;
     double m_radius;
-    BedsGrid::Gap m_gap;
+    Vec2crd m_gap;
 
 public:
-    CircleBed(): m_center(0, 0), m_radius(NaNd), m_gap(BedsGrid::Gap::Zero()) {}
-    explicit CircleBed(const Point& c, double r, const BedsGrid::Gap &g)
+    CircleBed(): m_center(0, 0), m_radius(NaNd), m_gap(Vec2crd::Zero()) {}
+    explicit CircleBed(const Point& c, double r, const Vec2crd &g)
         : m_center(c)
         , m_radius(r)
         , m_gap(g)
@@ -86,7 +85,7 @@ public:
 
     double radius() const { return m_radius; }
     const Point& center() const { return m_center; }
-    const BedsGrid::Gap &gap() const { return m_gap; }
+    const Vec2crd &gap() const { return m_gap; }
 };
 
 // Function to approximate a circle with a convex polygon
@@ -103,12 +102,12 @@ inline CircleBed offset(const CircleBed &bed, coord_t v)
 {
     return CircleBed{bed.center(), bed.radius() + v, bed.gap()};
 }
-inline BedsGrid::Gap bed_gap(const CircleBed &bed)
+inline Vec2crd bed_gap(const CircleBed &bed)
 {
     return bed.gap();
 }
 
-struct IrregularBed { ExPolygons poly; BedsGrid::Gap gap; };
+struct IrregularBed { ExPolygons poly; Vec2crd gap; };
 inline BoundingBox bounding_box(const IrregularBed &bed)
 {
     return get_extents(bed.poly);
@@ -119,7 +118,7 @@ inline IrregularBed offset(IrregularBed bed, coord_t v)
     bed.poly = offset_ex(bed.poly, v);
     return bed;
 }
-inline BedsGrid::Gap bed_gap(const IrregularBed &bed)
+inline Vec2crd bed_gap(const IrregularBed &bed)
 {
     return bed.gap;
 }
@@ -144,9 +143,9 @@ inline ArrangeBed offset(ArrangeBed bed, coord_t v)
     return bed;
 }
 
-inline BedsGrid::Gap bed_gap(const ArrangeBed &bed)
+inline Vec2crd bed_gap(const ArrangeBed &bed)
 {
-    BedsGrid::Gap ret;
+    Vec2crd ret;
     auto visitor = [&ret](const auto &b) { ret = bed_gap(b); };
     boost::apply_visitor(visitor, bed);
 
@@ -216,7 +215,7 @@ inline ExPolygons to_expolygons(const ArrangeBed &bed)
     return ret;
 }
 
-ArrangeBed to_arrange_bed(const Points &bedpts, const BedsGrid::Gap &gap);
+ArrangeBed to_arrange_bed(const Points &bedpts, const Vec2crd &gap);
 
 template<class Bed, class En = void> struct IsRectangular_ : public std::false_type {};
 template<> struct IsRectangular_<RectangleBed>: public std::true_type {};
diff --git a/src/slic3r-arrange/include/arrange/NFP/Kernels/RectangleOverfitKernelWrapper.hpp b/src/slic3r-arrange/include/arrange/NFP/Kernels/RectangleOverfitKernelWrapper.hpp
index 0bcca8bb2a..1742e1d230 100644
--- a/src/slic3r-arrange/include/arrange/NFP/Kernels/RectangleOverfitKernelWrapper.hpp
+++ b/src/slic3r-arrange/include/arrange/NFP/Kernels/RectangleOverfitKernelWrapper.hpp
@@ -74,7 +74,7 @@ struct RectangleOverfitKernelWrapper {
         for (auto &fitm : all_items_range(packing_context))
             pilebb.merge(fixed_bounding_box(fitm));
 
-        return KernelTraits<Kernel>::on_start_packing(k, itm, RectangleBed{binbb, BedsGrid::Gap::Zero()},
+        return KernelTraits<Kernel>::on_start_packing(k, itm, RectangleBed{binbb, Vec2crd::Zero()},
                                                       packing_context,
                                                       remaining_items);
     }
diff --git a/src/slic3r-arrange/src/Beds.cpp b/src/slic3r-arrange/src/Beds.cpp
index 7e29dd570e..8a741eb0a3 100644
--- a/src/slic3r-arrange/src/Beds.cpp
+++ b/src/slic3r-arrange/src/Beds.cpp
@@ -84,7 +84,7 @@ inline double distance_to(const Point &p1, const Point &p2)
     return std::sqrt(dx * dx + dy * dy);
 }
 
-static CircleBed to_circle(const Point &center, const Points &points, const BedsGrid::Gap &gap)
+static CircleBed to_circle(const Point &center, const Points &points, const Vec2crd &gap)
 {
     std::vector<double> vertex_distances;
     double              avg_dist = 0;
@@ -108,7 +108,7 @@ static CircleBed to_circle(const Point &center, const Points &points, const Beds
     return ret;
 }
 
-template<class Fn> auto call_with_bed(const Points &bed, const BedsGrid::Gap &gap, Fn &&fn)
+template<class Fn> auto call_with_bed(const Points &bed, const Vec2crd &gap, Fn &&fn)
 {
     if (bed.empty())
         return fn(InfiniteBed{});
@@ -128,7 +128,7 @@ template<class Fn> auto call_with_bed(const Points &bed, const BedsGrid::Gap &ga
     }
 }
 
-ArrangeBed to_arrange_bed(const Points &bedpts, const BedsGrid::Gap &gap)
+ArrangeBed to_arrange_bed(const Points &bedpts, const Vec2crd &gap)
 {
     ArrangeBed ret;
 
diff --git a/src/slic3r/GUI/Jobs/ArrangeJob2.cpp b/src/slic3r/GUI/Jobs/ArrangeJob2.cpp
index f3829491c0..bc6a367cd8 100644
--- a/src/slic3r/GUI/Jobs/ArrangeJob2.cpp
+++ b/src/slic3r/GUI/Jobs/ArrangeJob2.cpp
@@ -10,6 +10,7 @@
 #include <libslic3r/Model.hpp>
 #include <libslic3r/TriangleMeshSlicer.hpp>
 #include <libslic3r/Geometry/ConvexHull.hpp>
+#include <libslic3r/MultipleBeds.hpp>
 
 #include <libslic3r/SLAPrint.hpp>
 #include <libslic3r/Print.hpp>
@@ -312,7 +313,7 @@ arr2::SceneBuilder build_scene(Plater &plater, ArrangeSelectionMode mode)
     }
 
     if (plater.config()) {
-        const BedsGrid::Gap gap{s_multiple_beds.get_bed_gap()};
+        const Vec2crd gap{s_multiple_beds.get_bed_gap()};
         builder.set_bed(*plater.config(), gap);
     }
 
diff --git a/tests/arrange/test_arrange.cpp b/tests/arrange/test_arrange.cpp
index c5790d6910..c418bbb864 100644
--- a/tests/arrange/test_arrange.cpp
+++ b/tests/arrange/test_arrange.cpp
@@ -382,7 +382,7 @@ template<> inline Slic3r::arr2::RectangleBed init_bed<Slic3r::arr2::RectangleBed
 
 template<> inline Slic3r::arr2::CircleBed init_bed<Slic3r::arr2::CircleBed>()
 {
-    return Slic3r::arr2::CircleBed{Slic3r::Point::Zero(), scaled(300.), Slic3r::BedsGrid::Gap{0, 0}};
+    return Slic3r::arr2::CircleBed{Slic3r::Point::Zero(), scaled(300.), Slic3r::Vec2crd{0, 0}};
 }
 
 template<> inline Slic3r::arr2::IrregularBed init_bed<Slic3r::arr2::IrregularBed>()
diff --git a/tests/fff_print/test_data.cpp b/tests/fff_print/test_data.cpp
index 742458dfe5..9dbd1c7f66 100644
--- a/tests/fff_print/test_data.cpp
+++ b/tests/fff_print/test_data.cpp
@@ -255,7 +255,7 @@ void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r
     double distance = min_object_distance(config);
     arr2::ArrangeSettings arrange_settings{};
     arrange_settings.set_distance_from_objects(distance);
-    arr2::ArrangeBed bed{arr2::to_arrange_bed(get_bed_shape(config), BedsGrid::Gap{0, 0})};
+    arr2::ArrangeBed bed{arr2::to_arrange_bed(get_bed_shape(config), Vec2crd{0, 0})};
     if (duplicate_count > 1) {
         duplicate(model, duplicate_count, bed, arrange_settings);
     }
diff --git a/tests/slic3rutils/slic3r_arrangejob_tests.cpp b/tests/slic3rutils/slic3r_arrangejob_tests.cpp
index 4aac99b963..1cd35de5b4 100644
--- a/tests/slic3rutils/slic3r_arrangejob_tests.cpp
+++ b/tests/slic3rutils/slic3r_arrangejob_tests.cpp
@@ -90,14 +90,14 @@ TEST_CASE("Basic arrange with cube", "[arrangejob]") {
     arr2::ArrangeSettings settings;
 
     Points bedpts = get_bed_shape(cfg);
-    arr2::ArrangeBed bed = arr2::to_arrange_bed(bedpts, BedsGrid::Gap{0, 0});
+    arr2::ArrangeBed bed = arr2::to_arrange_bed(bedpts, Vec2crd{0, 0});
 
     SECTION("Single cube needs to be centered") {
         w.push(std::make_unique<ArrangeJob2>(arr2::Scene{
             arr2::SceneBuilder{}
                 .set_model(m)
                 .set_arrange_settings(&settings)
-                .set_bed(cfg, BedsGrid::Gap{0, 0})}));
+                .set_bed(cfg, Vec2crd{0, 0})}));
 
         w.process_events();
 
@@ -126,7 +126,7 @@ TEST_CASE("Basic arrange with cube", "[arrangejob]") {
         arr2::Scene   scene{arr2::SceneBuilder{}
                                      .set_model(m)
                                      .set_arrange_settings(&settings)
-                                     .set_bed(cfg, BedsGrid::Gap{0, 0})
+                                     .set_bed(cfg, Vec2crd{0, 0})
                                      .set_selection(&sel)};
 
         w.push(std::make_unique<ArrangeJob2>(std::move(scene)));
@@ -160,7 +160,7 @@ TEST_CASE("Basic arrange with cube", "[arrangejob]") {
         arr2::Scene   scene{arr2::SceneBuilder{}
                                      .set_model(m)
                                      .set_arrange_settings(&settings)
-                                     .set_bed(cfg, BedsGrid::Gap{0, 0})
+                                     .set_bed(cfg, Vec2crd{0, 0})
                                      .set_selection(&sel)};
 
         w.push(std::make_unique<ArrangeJob2>(std::move(scene)));
@@ -266,7 +266,7 @@ TEST_CASE("Test for modifying model during arrangement", "[arrangejob][fillbedjo
     new_volume->name = new_object->name;
 
     Points bedpts = get_bed_shape(cfg);
-    arr2::ArrangeBed bed = arr2::to_arrange_bed(bedpts, BedsGrid::Gap{0, 0});
+    arr2::ArrangeBed bed = arr2::to_arrange_bed(bedpts, Vec2crd{0, 0});
 
     BoostThreadWorker w(std::make_unique<DummyProgress>());
     RandomArrangeSettings settings;
@@ -278,7 +278,7 @@ TEST_CASE("Test for modifying model during arrangement", "[arrangejob][fillbedjo
         arr2::Scene scene{arr2::SceneBuilder{}
                                      .set_model(m)
                                      .set_arrange_settings(&settings)
-                                     .set_bed(cfg, BedsGrid::Gap{0, 0})};
+                                     .set_bed(cfg, Vec2crd{0, 0})};
 
         ArrangeJob2::Callbacks cbs;
         cbs.on_prepared = [&m] (auto &) {