// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/struct.Bitset.html).
pub type Bitset

///|
pub(open) trait IBitset {
  fn as_bitset(Self) -> Bitset
  fn add(Self, UInt) -> Bool = _
  fn add_range(Self, UInt, UInt) -> Unit = _
  fn add_range_closed(Self, UInt, UInt) -> Unit = _
  fn add_rectangle(Self, UInt, UInt, UInt, UInt) -> Unit = _
  fn contains(Self, UInt) -> Bool = _
  fn difference(Self, Bitset) -> Unit = _
  fn equals(Self, Bitset) -> Bool = _
  fn get_maximum(Self) -> UInt = _
  fn get_minimum(Self) -> UInt = _
  fn get_nth(Self, UInt) -> UInt = _
  fn get_size(Self) -> UInt64 = _
  fn get_size_in_range(Self, UInt, UInt) -> UInt64 = _
  fn intersect(Self, Bitset) -> Unit = _
  fn is_empty(Self) -> Bool = _
  fn ref_(Self) -> Bitset = _
  fn remove(Self, UInt) -> Bool = _
  fn remove_all(Self) -> Unit = _
  fn remove_range(Self, UInt, UInt) -> Unit = _
  fn remove_range_closed(Self, UInt, UInt) -> Unit = _
  fn remove_rectangle(Self, UInt, UInt, UInt, UInt) -> Unit = _
  fn shift_left(Self, UInt) -> Unit = _
  fn shift_right(Self, UInt) -> Unit = _
  fn splice(Self, UInt, UInt, UInt) -> Unit = _
  fn subtract(Self, Bitset) -> Unit = _
  fn union(Self, Bitset) -> Unit = _
}

///|
pub impl IBitset for Bitset with fn as_bitset(self) {
  self
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/ctor.Bitset.new_empty.html).
pub extern "c" fn Bitset::new_empty() -> Bitset = "moonbit_gtk_bitset_new_empty"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/ctor.Bitset.new_range.html).
pub extern "c" fn Bitset::new_range(start : UInt, n_items : UInt) -> Bitset = "moonbit_gtk_bitset_new_range"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.add.html).
#borrow(self)
pub extern "c" fn Bitset::add(self : Bitset, value : UInt) -> Bool = "moonbit_gtk_bitset_add"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.add_range.html).
#borrow(self)
pub extern "c" fn Bitset::add_range(
  self : Bitset,
  start : UInt,
  n_items : UInt,
) = "moonbit_gtk_bitset_add_range"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.add_range_closed.html).
#borrow(self)
pub extern "c" fn Bitset::add_range_closed(
  self : Bitset,
  first : UInt,
  last : UInt,
) = "moonbit_gtk_bitset_add_range_closed"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.add_rectangle.html).
#borrow(self)
pub extern "c" fn Bitset::add_rectangle(
  self : Bitset,
  start : UInt,
  width : UInt,
  height : UInt,
  stride : UInt,
) = "moonbit_gtk_bitset_add_rectangle"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.contains.html).
#borrow(self)
pub extern "c" fn Bitset::contains(self : Bitset, value : UInt) -> Bool = "moonbit_gtk_bitset_contains"

///|
#borrow(self_, other)
extern "c" fn moonbit_gtk_bitset_difference(self_ : Bitset, other : Bitset) = "moonbit_gtk_bitset_difference"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.difference.html).
pub fn Bitset::difference(self : Bitset, other : Bitset) -> Unit {
  moonbit_gtk_bitset_difference(self, other)
}

///|
#borrow(self_, other)
extern "c" fn moonbit_gtk_bitset_equals(self_ : Bitset, other : Bitset) -> Bool = "moonbit_gtk_bitset_equals"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.equals.html).
pub fn Bitset::equals(self : Bitset, other : Bitset) -> Bool {
  moonbit_gtk_bitset_equals(self, other)
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.get_maximum.html).
#borrow(self)
pub extern "c" fn Bitset::get_maximum(self : Bitset) -> UInt = "moonbit_gtk_bitset_get_maximum"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.get_minimum.html).
#borrow(self)
pub extern "c" fn Bitset::get_minimum(self : Bitset) -> UInt = "moonbit_gtk_bitset_get_minimum"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.get_nth.html).
#borrow(self)
pub extern "c" fn Bitset::get_nth(self : Bitset, nth : UInt) -> UInt = "moonbit_gtk_bitset_get_nth"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.get_size.html).
#borrow(self)
pub extern "c" fn Bitset::get_size(self : Bitset) -> UInt64 = "moonbit_gtk_bitset_get_size"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.get_size_in_range.html).
#borrow(self)
pub extern "c" fn Bitset::get_size_in_range(
  self : Bitset,
  first : UInt,
  last : UInt,
) -> UInt64 = "moonbit_gtk_bitset_get_size_in_range"

///|
#borrow(self_, other)
extern "c" fn moonbit_gtk_bitset_intersect(self_ : Bitset, other : Bitset) = "moonbit_gtk_bitset_intersect"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.intersect.html).
pub fn Bitset::intersect(self : Bitset, other : Bitset) -> Unit {
  moonbit_gtk_bitset_intersect(self, other)
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.is_empty.html).
#borrow(self)
pub extern "c" fn Bitset::is_empty(self : Bitset) -> Bool = "moonbit_gtk_bitset_is_empty"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.ref.html).
#borrow(self)
pub extern "c" fn Bitset::ref_(self : Bitset) -> Bitset = "moonbit_gtk_bitset_ref"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.remove.html).
#borrow(self)
pub extern "c" fn Bitset::remove(self : Bitset, value : UInt) -> Bool = "moonbit_gtk_bitset_remove"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.remove_all.html).
#borrow(self)
pub extern "c" fn Bitset::remove_all(self : Bitset) = "moonbit_gtk_bitset_remove_all"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.remove_range.html).
#borrow(self)
pub extern "c" fn Bitset::remove_range(
  self : Bitset,
  start : UInt,
  n_items : UInt,
) = "moonbit_gtk_bitset_remove_range"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.remove_range_closed.html).
#borrow(self)
pub extern "c" fn Bitset::remove_range_closed(
  self : Bitset,
  first : UInt,
  last : UInt,
) = "moonbit_gtk_bitset_remove_range_closed"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.remove_rectangle.html).
#borrow(self)
pub extern "c" fn Bitset::remove_rectangle(
  self : Bitset,
  start : UInt,
  width : UInt,
  height : UInt,
  stride : UInt,
) = "moonbit_gtk_bitset_remove_rectangle"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.shift_left.html).
#borrow(self)
pub extern "c" fn Bitset::shift_left(self : Bitset, amount : UInt) = "moonbit_gtk_bitset_shift_left"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.shift_right.html).
#borrow(self)
pub extern "c" fn Bitset::shift_right(self : Bitset, amount : UInt) = "moonbit_gtk_bitset_shift_right"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.splice.html).
#borrow(self)
pub extern "c" fn Bitset::splice(
  self : Bitset,
  position : UInt,
  removed : UInt,
  added : UInt,
) = "moonbit_gtk_bitset_splice"

///|
#borrow(self_, other)
extern "c" fn moonbit_gtk_bitset_subtract(self_ : Bitset, other : Bitset) = "moonbit_gtk_bitset_subtract"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.subtract.html).
pub fn Bitset::subtract(self : Bitset, other : Bitset) -> Unit {
  moonbit_gtk_bitset_subtract(self, other)
}

///|
#borrow(self_, other)
extern "c" fn moonbit_gtk_bitset_union(self_ : Bitset, other : Bitset) = "moonbit_gtk_bitset_union"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Bitset.union.html).
pub fn Bitset::union(self : Bitset, other : Bitset) -> Unit {
  moonbit_gtk_bitset_union(self, other)
}

///|
impl IBitset with fn add(self, value) -> Bool {
  self.as_bitset().add(value)
}

///|
impl IBitset with fn add_range(self, start, n_items) -> Unit {
  self.as_bitset().add_range(start, n_items)
}

///|
impl IBitset with fn add_range_closed(self, first, last) -> Unit {
  self.as_bitset().add_range_closed(first, last)
}

///|
impl IBitset with fn add_rectangle(self, start, width, height, stride) -> Unit {
  self.as_bitset().add_rectangle(start, width, height, stride)
}

///|
impl IBitset with fn contains(self, value) -> Bool {
  self.as_bitset().contains(value)
}

///|
impl IBitset with fn difference(self, other) -> Unit {
  self.as_bitset().difference(other)
}

///|
impl IBitset with fn equals(self, other) -> Bool {
  self.as_bitset().equals(other)
}

///|
impl IBitset with fn get_maximum(self) -> UInt {
  self.as_bitset().get_maximum()
}

///|
impl IBitset with fn get_minimum(self) -> UInt {
  self.as_bitset().get_minimum()
}

///|
impl IBitset with fn get_nth(self, nth) -> UInt {
  self.as_bitset().get_nth(nth)
}

///|
impl IBitset with fn get_size(self) -> UInt64 {
  self.as_bitset().get_size()
}

///|
impl IBitset with fn get_size_in_range(self, first, last) -> UInt64 {
  self.as_bitset().get_size_in_range(first, last)
}

///|
impl IBitset with fn intersect(self, other) -> Unit {
  self.as_bitset().intersect(other)
}

///|
impl IBitset with fn is_empty(self) -> Bool {
  self.as_bitset().is_empty()
}

///|
impl IBitset with fn ref_(self) -> Bitset {
  self.as_bitset().ref_()
}

///|
impl IBitset with fn remove(self, value) -> Bool {
  self.as_bitset().remove(value)
}

///|
impl IBitset with fn remove_all(self) -> Unit {
  self.as_bitset().remove_all()
}

///|
impl IBitset with fn remove_range(self, start, n_items) -> Unit {
  self.as_bitset().remove_range(start, n_items)
}

///|
impl IBitset with fn remove_range_closed(self, first, last) -> Unit {
  self.as_bitset().remove_range_closed(first, last)
}

///|
impl IBitset with fn remove_rectangle(self, start, width, height, stride) -> Unit {
  self.as_bitset().remove_rectangle(start, width, height, stride)
}

///|
impl IBitset with fn shift_left(self, amount) -> Unit {
  self.as_bitset().shift_left(amount)
}

///|
impl IBitset with fn shift_right(self, amount) -> Unit {
  self.as_bitset().shift_right(amount)
}

///|
impl IBitset with fn splice(self, position, removed, added) -> Unit {
  self.as_bitset().splice(position, removed, added)
}

///|
impl IBitset with fn subtract(self, other) -> Unit {
  self.as_bitset().subtract(other)
}

///|
impl IBitset with fn union(self, other) -> Unit {
  self.as_bitset().union(other)
}