// GENERATED — DO NOT EDIT

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

///|
pub(open) trait INotebook {
  fn as_notebook(Self) -> Notebook
  fn append_page(Self, &IWidget, &IWidget?) -> Int = _
  fn append_page_menu(Self, &IWidget, &IWidget?, &IWidget?) -> Int = _
  fn detach_tab(Self, &IWidget) -> Unit = _
  fn get_action_widget(Self, PackType) -> Widget? = _
  fn get_current_page(Self) -> Int = _
  fn get_group_name(Self) -> String? = _
  fn get_menu_label(Self, &IWidget) -> Widget? = _
  fn get_menu_label_text(Self, &IWidget) -> String? = _
  fn get_n_pages(Self) -> Int = _
  fn get_nth_page(Self, Int) -> Widget? = _
  fn get_page(Self, &IWidget) -> NotebookPage = _
  fn get_pages(Self) -> @gio.ListModel = _
  fn get_scrollable(Self) -> Bool = _
  fn get_show_border(Self) -> Bool = _
  fn get_show_tabs(Self) -> Bool = _
  fn get_tab_detachable(Self, &IWidget) -> Bool = _
  fn get_tab_label(Self, &IWidget) -> Widget? = _
  fn get_tab_label_text(Self, &IWidget) -> String? = _
  fn get_tab_pos(Self) -> PositionType = _
  fn get_tab_reorderable(Self, &IWidget) -> Bool = _
  fn insert_page(Self, &IWidget, &IWidget?, Int) -> Int = _
  fn insert_page_menu(Self, &IWidget, &IWidget?, &IWidget?, Int) -> Int = _
  fn next_page(Self) -> Unit = _
  fn page_num(Self, &IWidget) -> Int = _
  fn popup_disable(Self) -> Unit = _
  fn popup_enable(Self) -> Unit = _
  fn prepend_page(Self, &IWidget, &IWidget?) -> Int = _
  fn prepend_page_menu(Self, &IWidget, &IWidget?, &IWidget?) -> Int = _
  fn prev_page(Self) -> Unit = _
  fn remove_page(Self, Int) -> Unit = _
  fn reorder_child(Self, &IWidget, Int) -> Unit = _
  fn set_action_widget(Self, &IWidget, PackType) -> Unit = _
  fn set_current_page(Self, Int) -> Unit = _
  fn set_group_name(Self, String?) -> Unit = _
  fn set_menu_label(Self, &IWidget, &IWidget?) -> Unit = _
  fn set_menu_label_text(Self, &IWidget, String) -> Unit = _
  fn set_scrollable(Self, Bool) -> Unit = _
  fn set_show_border(Self, Bool) -> Unit = _
  fn set_show_tabs(Self, Bool) -> Unit = _
  fn set_tab_detachable(Self, &IWidget, Bool) -> Unit = _
  fn set_tab_label(Self, &IWidget, &IWidget?) -> Unit = _
  fn set_tab_label_text(Self, &IWidget, String) -> Unit = _
  fn set_tab_pos(Self, PositionType) -> Unit = _
  fn set_tab_reorderable(Self, &IWidget, Bool) -> Unit = _
  fn connect_change_current_page(Self, (Notebook, Int) -> Bool) -> UInt64 = _
  fn connect_focus_tab(Self, (Notebook, NotebookTab) -> Bool) -> UInt64 = _
  fn connect_move_focus_out(Self, (Notebook, DirectionType) -> Unit) -> UInt64 = _
  fn connect_page_added(Self, (Notebook, Widget, UInt) -> Unit) -> UInt64 = _
  fn connect_page_removed(Self, (Notebook, Widget, UInt) -> Unit) -> UInt64 = _
  fn connect_page_reordered(Self, (Notebook, Widget, UInt) -> Unit) -> UInt64 = _
  fn connect_reorder_tab(Self, (Notebook, DirectionType, Bool) -> Bool) -> UInt64 = _
  fn connect_select_page(Self, (Notebook, Bool) -> Bool) -> UInt64 = _
  fn connect_switch_page(Self, (Notebook, Widget, UInt) -> Unit) -> UInt64 = _
}

///|
pub impl INotebook for Notebook with fn as_notebook(self) {
  self
}

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

///|
#borrow(self_, child, tab_label)
extern "c" fn moonbit_gtk_notebook_append_page(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
) -> Int = "moonbit_gtk_notebook_append_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.append_page.html).
pub fn Notebook::append_page(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
) -> Int {
  moonbit_gtk_notebook_append_page(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, child, tab_label, menu_label)
extern "c" fn moonbit_gtk_notebook_append_page_menu(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
  menu_label : @glib.Nullable[Widget],
) -> Int = "moonbit_gtk_notebook_append_page_menu"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.append_page_menu.html).
pub fn Notebook::append_page_menu(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
  menu_label : &IWidget?,
) -> Int {
  moonbit_gtk_notebook_append_page_menu(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
    match menu_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_detach_tab(self_ : Notebook, child : Widget) = "moonbit_gtk_notebook_detach_tab"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.detach_tab.html).
pub fn Notebook::detach_tab(self : Notebook, child : &IWidget) -> Unit {
  moonbit_gtk_notebook_detach_tab(self, child.as_widget())
}

///|
#borrow(self_)
extern "c" fn moonbit_gtk_notebook_get_action_widget(
  self_ : Notebook,
  pack_type : PackType,
) -> @glib.Nullable[Widget] = "moonbit_gtk_notebook_get_action_widget"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_action_widget.html).
pub fn Notebook::get_action_widget(
  self : Notebook,
  pack_type : PackType,
) -> Widget? {
  let raw_result = moonbit_gtk_notebook_get_action_widget(self, pack_type)
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_current_page.html).
#borrow(self)
pub extern "c" fn Notebook::get_current_page(self : Notebook) -> Int = "moonbit_gtk_notebook_get_current_page"

///|
#borrow(self_)
extern "c" fn moonbit_gtk_notebook_get_group_name(
  self_ : Notebook,
) -> @glib.Nullable[Bytes] = "moonbit_gtk_notebook_get_group_name"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_group_name.html).
pub fn Notebook::get_group_name(self : Notebook) -> String? {
  let result = moonbit_gtk_notebook_get_group_name(self)
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_menu_label(
  self_ : Notebook,
  child : Widget,
) -> @glib.Nullable[Widget] = "moonbit_gtk_notebook_get_menu_label"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_menu_label.html).
pub fn Notebook::get_menu_label(self : Notebook, child : &IWidget) -> Widget? {
  let raw_result = moonbit_gtk_notebook_get_menu_label(self, child.as_widget())
  raw_result.to_option()
}

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_menu_label_text(
  self_ : Notebook,
  child : Widget,
) -> @glib.Nullable[Bytes] = "moonbit_gtk_notebook_get_menu_label_text"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_menu_label_text.html).
pub fn Notebook::get_menu_label_text(
  self : Notebook,
  child : &IWidget,
) -> String? {
  let result = moonbit_gtk_notebook_get_menu_label_text(self, child.as_widget())
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_n_pages.html).
#borrow(self)
pub extern "c" fn Notebook::get_n_pages(self : Notebook) -> Int = "moonbit_gtk_notebook_get_n_pages"

///|
#borrow(self_)
extern "c" fn moonbit_gtk_notebook_get_nth_page(
  self_ : Notebook,
  page_num : Int,
) -> @glib.Nullable[Widget] = "moonbit_gtk_notebook_get_nth_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_nth_page.html).
pub fn Notebook::get_nth_page(self : Notebook, page_num : Int) -> Widget? {
  let raw_result = moonbit_gtk_notebook_get_nth_page(self, page_num)
  raw_result.to_option()
}

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_page(
  self_ : Notebook,
  child : Widget,
) -> NotebookPage = "moonbit_gtk_notebook_get_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_page.html).
pub fn Notebook::get_page(self : Notebook, child : &IWidget) -> NotebookPage {
  moonbit_gtk_notebook_get_page(self, child.as_widget())
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_pages.html).
#borrow(self)
pub extern "c" fn Notebook::get_pages(self : Notebook) -> @gio.ListModel = "moonbit_gtk_notebook_get_pages"

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

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

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

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_tab_detachable(
  self_ : Notebook,
  child : Widget,
) -> Bool = "moonbit_gtk_notebook_get_tab_detachable"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_tab_detachable.html).
pub fn Notebook::get_tab_detachable(self : Notebook, child : &IWidget) -> Bool {
  moonbit_gtk_notebook_get_tab_detachable(self, child.as_widget())
}

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_tab_label(
  self_ : Notebook,
  child : Widget,
) -> @glib.Nullable[Widget] = "moonbit_gtk_notebook_get_tab_label"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_tab_label.html).
pub fn Notebook::get_tab_label(self : Notebook, child : &IWidget) -> Widget? {
  let raw_result = moonbit_gtk_notebook_get_tab_label(self, child.as_widget())
  raw_result.to_option()
}

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_tab_label_text(
  self_ : Notebook,
  child : Widget,
) -> @glib.Nullable[Bytes] = "moonbit_gtk_notebook_get_tab_label_text"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_tab_label_text.html).
pub fn Notebook::get_tab_label_text(
  self : Notebook,
  child : &IWidget,
) -> String? {
  let result = moonbit_gtk_notebook_get_tab_label_text(self, child.as_widget())
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_tab_pos.html).
#borrow(self)
pub extern "c" fn Notebook::get_tab_pos(self : Notebook) -> PositionType = "moonbit_gtk_notebook_get_tab_pos"

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_get_tab_reorderable(
  self_ : Notebook,
  child : Widget,
) -> Bool = "moonbit_gtk_notebook_get_tab_reorderable"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.get_tab_reorderable.html).
pub fn Notebook::get_tab_reorderable(self : Notebook, child : &IWidget) -> Bool {
  moonbit_gtk_notebook_get_tab_reorderable(self, child.as_widget())
}

///|
#borrow(self_, child, tab_label)
extern "c" fn moonbit_gtk_notebook_insert_page(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
  position : Int,
) -> Int = "moonbit_gtk_notebook_insert_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.insert_page.html).
pub fn Notebook::insert_page(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
  position : Int,
) -> Int {
  moonbit_gtk_notebook_insert_page(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
    position,
  )
}

///|
#borrow(self_, child, tab_label, menu_label)
extern "c" fn moonbit_gtk_notebook_insert_page_menu(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
  menu_label : @glib.Nullable[Widget],
  position : Int,
) -> Int = "moonbit_gtk_notebook_insert_page_menu"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.insert_page_menu.html).
pub fn Notebook::insert_page_menu(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
  menu_label : &IWidget?,
  position : Int,
) -> Int {
  moonbit_gtk_notebook_insert_page_menu(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
    match menu_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
    position,
  )
}

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

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_page_num(
  self_ : Notebook,
  child : Widget,
) -> Int = "moonbit_gtk_notebook_page_num"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.page_num.html).
pub fn Notebook::page_num(self : Notebook, child : &IWidget) -> Int {
  moonbit_gtk_notebook_page_num(self, child.as_widget())
}

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

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

///|
#borrow(self_, child, tab_label)
extern "c" fn moonbit_gtk_notebook_prepend_page(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
) -> Int = "moonbit_gtk_notebook_prepend_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.prepend_page.html).
pub fn Notebook::prepend_page(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
) -> Int {
  moonbit_gtk_notebook_prepend_page(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, child, tab_label, menu_label)
extern "c" fn moonbit_gtk_notebook_prepend_page_menu(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
  menu_label : @glib.Nullable[Widget],
) -> Int = "moonbit_gtk_notebook_prepend_page_menu"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.prepend_page_menu.html).
pub fn Notebook::prepend_page_menu(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
  menu_label : &IWidget?,
) -> Int {
  moonbit_gtk_notebook_prepend_page_menu(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
    match menu_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
  )
}

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

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.remove_page.html).
#borrow(self)
pub extern "c" fn Notebook::remove_page(self : Notebook, page_num : Int) = "moonbit_gtk_notebook_remove_page"

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_reorder_child(
  self_ : Notebook,
  child : Widget,
  position : Int,
) = "moonbit_gtk_notebook_reorder_child"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.reorder_child.html).
pub fn Notebook::reorder_child(
  self : Notebook,
  child : &IWidget,
  position : Int,
) -> Unit {
  moonbit_gtk_notebook_reorder_child(self, child.as_widget(), position)
}

///|
#borrow(self_, widget)
extern "c" fn moonbit_gtk_notebook_set_action_widget(
  self_ : Notebook,
  widget : Widget,
  pack_type : PackType,
) = "moonbit_gtk_notebook_set_action_widget"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_action_widget.html).
pub fn Notebook::set_action_widget(
  self : Notebook,
  widget : &IWidget,
  pack_type : PackType,
) -> Unit {
  moonbit_gtk_notebook_set_action_widget(self, widget.as_widget(), pack_type)
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_current_page.html).
#borrow(self)
pub extern "c" fn Notebook::set_current_page(self : Notebook, page_num : Int) = "moonbit_gtk_notebook_set_current_page"

///|
#borrow(self_, group_name)
extern "c" fn moonbit_gtk_notebook_set_group_name(
  self_ : Notebook,
  group_name : @glib.Nullable[Bytes],
) = "moonbit_gtk_notebook_set_group_name"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_group_name.html).
pub fn Notebook::set_group_name(self : Notebook, group_name : String?) -> Unit {
  moonbit_gtk_notebook_set_group_name(
    self,
    match group_name {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, child, menu_label)
extern "c" fn moonbit_gtk_notebook_set_menu_label(
  self_ : Notebook,
  child : Widget,
  menu_label : @glib.Nullable[Widget],
) = "moonbit_gtk_notebook_set_menu_label"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_menu_label.html).
pub fn Notebook::set_menu_label(
  self : Notebook,
  child : &IWidget,
  menu_label : &IWidget?,
) -> Unit {
  moonbit_gtk_notebook_set_menu_label(
    self,
    child.as_widget(),
    match menu_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, child, menu_text)
extern "c" fn moonbit_gtk_notebook_set_menu_label_text(
  self_ : Notebook,
  child : Widget,
  menu_text : Bytes,
) = "moonbit_gtk_notebook_set_menu_label_text"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_menu_label_text.html).
pub fn Notebook::set_menu_label_text(
  self : Notebook,
  child : &IWidget,
  menu_text : String,
) -> Unit {
  moonbit_gtk_notebook_set_menu_label_text(
    self,
    child.as_widget(),
    @encoding/utf8.encode(menu_text),
  )
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_scrollable.html).
#borrow(self)
pub extern "c" fn Notebook::set_scrollable(self : Notebook, scrollable : Bool) = "moonbit_gtk_notebook_set_scrollable"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_show_border.html).
#borrow(self)
pub extern "c" fn Notebook::set_show_border(
  self : Notebook,
  show_border : Bool,
) = "moonbit_gtk_notebook_set_show_border"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_show_tabs.html).
#borrow(self)
pub extern "c" fn Notebook::set_show_tabs(self : Notebook, show_tabs : Bool) = "moonbit_gtk_notebook_set_show_tabs"

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_set_tab_detachable(
  self_ : Notebook,
  child : Widget,
  detachable : Bool,
) = "moonbit_gtk_notebook_set_tab_detachable"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_tab_detachable.html).
pub fn Notebook::set_tab_detachable(
  self : Notebook,
  child : &IWidget,
  detachable : Bool,
) -> Unit {
  moonbit_gtk_notebook_set_tab_detachable(self, child.as_widget(), detachable)
}

///|
#borrow(self_, child, tab_label)
extern "c" fn moonbit_gtk_notebook_set_tab_label(
  self_ : Notebook,
  child : Widget,
  tab_label : @glib.Nullable[Widget],
) = "moonbit_gtk_notebook_set_tab_label"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_tab_label.html).
pub fn Notebook::set_tab_label(
  self : Notebook,
  child : &IWidget,
  tab_label : &IWidget?,
) -> Unit {
  moonbit_gtk_notebook_set_tab_label(
    self,
    child.as_widget(),
    match tab_label {
      Some(v) => @glib.Nullable::some(v.as_widget())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, child, tab_text)
extern "c" fn moonbit_gtk_notebook_set_tab_label_text(
  self_ : Notebook,
  child : Widget,
  tab_text : Bytes,
) = "moonbit_gtk_notebook_set_tab_label_text"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_tab_label_text.html).
pub fn Notebook::set_tab_label_text(
  self : Notebook,
  child : &IWidget,
  tab_text : String,
) -> Unit {
  moonbit_gtk_notebook_set_tab_label_text(
    self,
    child.as_widget(),
    @encoding/utf8.encode(tab_text),
  )
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_tab_pos.html).
#borrow(self)
pub extern "c" fn Notebook::set_tab_pos(self : Notebook, pos : PositionType) = "moonbit_gtk_notebook_set_tab_pos"

///|
#borrow(self_, child)
extern "c" fn moonbit_gtk_notebook_set_tab_reorderable(
  self_ : Notebook,
  child : Widget,
  reorderable : Bool,
) = "moonbit_gtk_notebook_set_tab_reorderable"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.Notebook.set_tab_reorderable.html).
pub fn Notebook::set_tab_reorderable(
  self : Notebook,
  child : &IWidget,
  reorderable : Bool,
) -> Unit {
  moonbit_gtk_notebook_set_tab_reorderable(self, child.as_widget(), reorderable)
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_change_current_page(
  instance : Notebook,
  function : FuncRef[(Notebook, Int, (Notebook, Int) -> Bool) -> Bool],
  closure : (Notebook, Int) -> Bool,
) -> UInt64 = "moonbit_gtk_notebook_connect_change_current_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.change-current-page.html).
pub fn Notebook::connect_change_current_page(
  self : Notebook,
  f : (Notebook, Int) -> Bool,
) -> UInt64 {
  gtk_notebook_connect_change_current_page(
    self,
    fn(instance_, page, f) { f(instance_, page) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_focus_tab(
  instance : Notebook,
  function : FuncRef[
    (Notebook, NotebookTab, (Notebook, NotebookTab) -> Bool) -> Bool,
  ],
  closure : (Notebook, NotebookTab) -> Bool,
) -> UInt64 = "moonbit_gtk_notebook_connect_focus_tab"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.focus-tab.html).
pub fn Notebook::connect_focus_tab(
  self : Notebook,
  f : (Notebook, NotebookTab) -> Bool,
) -> UInt64 {
  gtk_notebook_connect_focus_tab(
    self,
    fn(instance_, tab, f) { f(instance_, tab) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_move_focus_out(
  instance : Notebook,
  function : FuncRef[
    (Notebook, DirectionType, (Notebook, DirectionType) -> Unit) -> Unit,
  ],
  closure : (Notebook, DirectionType) -> Unit,
) -> UInt64 = "moonbit_gtk_notebook_connect_move_focus_out"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.move-focus-out.html).
pub fn Notebook::connect_move_focus_out(
  self : Notebook,
  f : (Notebook, DirectionType) -> Unit,
) -> UInt64 {
  gtk_notebook_connect_move_focus_out(
    self,
    fn(instance_, direction, f) { f(instance_, direction) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_page_added(
  instance : Notebook,
  function : FuncRef[
    (Notebook, Widget, UInt, (Notebook, Widget, UInt) -> Unit) -> Unit,
  ],
  closure : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 = "moonbit_gtk_notebook_connect_page_added"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.page-added.html).
pub fn Notebook::connect_page_added(
  self : Notebook,
  f : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 {
  gtk_notebook_connect_page_added(
    self,
    fn(instance_, child, page_num, f) { f(instance_, child, page_num) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_page_removed(
  instance : Notebook,
  function : FuncRef[
    (Notebook, Widget, UInt, (Notebook, Widget, UInt) -> Unit) -> Unit,
  ],
  closure : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 = "moonbit_gtk_notebook_connect_page_removed"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.page-removed.html).
pub fn Notebook::connect_page_removed(
  self : Notebook,
  f : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 {
  gtk_notebook_connect_page_removed(
    self,
    fn(instance_, child, page_num, f) { f(instance_, child, page_num) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_page_reordered(
  instance : Notebook,
  function : FuncRef[
    (Notebook, Widget, UInt, (Notebook, Widget, UInt) -> Unit) -> Unit,
  ],
  closure : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 = "moonbit_gtk_notebook_connect_page_reordered"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.page-reordered.html).
pub fn Notebook::connect_page_reordered(
  self : Notebook,
  f : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 {
  gtk_notebook_connect_page_reordered(
    self,
    fn(instance_, child, page_num, f) { f(instance_, child, page_num) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_reorder_tab(
  instance : Notebook,
  function : FuncRef[
    (Notebook, DirectionType, Bool, (Notebook, DirectionType, Bool) -> Bool) -> Bool,
  ],
  closure : (Notebook, DirectionType, Bool) -> Bool,
) -> UInt64 = "moonbit_gtk_notebook_connect_reorder_tab"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.reorder-tab.html).
pub fn Notebook::connect_reorder_tab(
  self : Notebook,
  f : (Notebook, DirectionType, Bool) -> Bool,
) -> UInt64 {
  gtk_notebook_connect_reorder_tab(
    self,
    fn(instance_, direction, move_to_last, f) {
      f(instance_, direction, move_to_last)
    },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_select_page(
  instance : Notebook,
  function : FuncRef[(Notebook, Bool, (Notebook, Bool) -> Bool) -> Bool],
  closure : (Notebook, Bool) -> Bool,
) -> UInt64 = "moonbit_gtk_notebook_connect_select_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.select-page.html).
pub fn Notebook::connect_select_page(
  self : Notebook,
  f : (Notebook, Bool) -> Bool,
) -> UInt64 {
  gtk_notebook_connect_select_page(
    self,
    fn(instance_, move_focus, f) { f(instance_, move_focus) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_notebook_connect_switch_page(
  instance : Notebook,
  function : FuncRef[
    (Notebook, Widget, UInt, (Notebook, Widget, UInt) -> Unit) -> Unit,
  ],
  closure : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 = "moonbit_gtk_notebook_connect_switch_page"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.Notebook.switch-page.html).
pub fn Notebook::connect_switch_page(
  self : Notebook,
  f : (Notebook, Widget, UInt) -> Unit,
) -> UInt64 {
  gtk_notebook_connect_switch_page(
    self,
    fn(instance_, page, page_num, f) { f(instance_, page, page_num) },
    f,
  )
}

///|
#borrow(self_)
extern "c" fn moonbit_gtk_notebook_get_enable_popup(self_ : Notebook) -> Int = "moonbit_gtk_notebook_get_enable_popup"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/property.Notebook.enable-popup.html).
pub fn Notebook::get_enable_popup(self : Notebook) -> Bool {
  moonbit_gtk_notebook_get_enable_popup(self) != 0
}

///|
#borrow(self_)
extern "c" fn moonbit_gtk_notebook_set_enable_popup(
  self_ : Notebook,
  value : Int,
) = "moonbit_gtk_notebook_set_enable_popup"

///|
pub fn Notebook::set_enable_popup(self : Notebook, value : Bool) -> Unit {
  moonbit_gtk_notebook_set_enable_popup(self, if value { 1 } else { 0 })
}

///|
impl INotebook with fn append_page(self, child, tab_label) -> Int {
  self.as_notebook().append_page(child, tab_label)
}

///|
impl INotebook with fn append_page_menu(self, child, tab_label, menu_label) -> Int {
  self.as_notebook().append_page_menu(child, tab_label, menu_label)
}

///|
impl INotebook with fn detach_tab(self, child) -> Unit {
  self.as_notebook().detach_tab(child)
}

///|
impl INotebook with fn get_action_widget(self, pack_type) -> Widget? {
  self.as_notebook().get_action_widget(pack_type)
}

///|
impl INotebook with fn get_current_page(self) -> Int {
  self.as_notebook().get_current_page()
}

///|
impl INotebook with fn get_group_name(self) -> String? {
  self.as_notebook().get_group_name()
}

///|
impl INotebook with fn get_menu_label(self, child) -> Widget? {
  self.as_notebook().get_menu_label(child)
}

///|
impl INotebook with fn get_menu_label_text(self, child) -> String? {
  self.as_notebook().get_menu_label_text(child)
}

///|
impl INotebook with fn get_n_pages(self) -> Int {
  self.as_notebook().get_n_pages()
}

///|
impl INotebook with fn get_nth_page(self, page_num) -> Widget? {
  self.as_notebook().get_nth_page(page_num)
}

///|
impl INotebook with fn get_page(self, child) -> NotebookPage {
  self.as_notebook().get_page(child)
}

///|
impl INotebook with fn get_pages(self) -> @gio.ListModel {
  self.as_notebook().get_pages()
}

///|
impl INotebook with fn get_scrollable(self) -> Bool {
  self.as_notebook().get_scrollable()
}

///|
impl INotebook with fn get_show_border(self) -> Bool {
  self.as_notebook().get_show_border()
}

///|
impl INotebook with fn get_show_tabs(self) -> Bool {
  self.as_notebook().get_show_tabs()
}

///|
impl INotebook with fn get_tab_detachable(self, child) -> Bool {
  self.as_notebook().get_tab_detachable(child)
}

///|
impl INotebook with fn get_tab_label(self, child) -> Widget? {
  self.as_notebook().get_tab_label(child)
}

///|
impl INotebook with fn get_tab_label_text(self, child) -> String? {
  self.as_notebook().get_tab_label_text(child)
}

///|
impl INotebook with fn get_tab_pos(self) -> PositionType {
  self.as_notebook().get_tab_pos()
}

///|
impl INotebook with fn get_tab_reorderable(self, child) -> Bool {
  self.as_notebook().get_tab_reorderable(child)
}

///|
impl INotebook with fn insert_page(self, child, tab_label, position) -> Int {
  self.as_notebook().insert_page(child, tab_label, position)
}

///|
impl INotebook with fn insert_page_menu(
  self,
  child,
  tab_label,
  menu_label,
  position,
) -> Int {
  self.as_notebook().insert_page_menu(child, tab_label, menu_label, position)
}

///|
impl INotebook with fn next_page(self) -> Unit {
  self.as_notebook().next_page()
}

///|
impl INotebook with fn page_num(self, child) -> Int {
  self.as_notebook().page_num(child)
}

///|
impl INotebook with fn popup_disable(self) -> Unit {
  self.as_notebook().popup_disable()
}

///|
impl INotebook with fn popup_enable(self) -> Unit {
  self.as_notebook().popup_enable()
}

///|
impl INotebook with fn prepend_page(self, child, tab_label) -> Int {
  self.as_notebook().prepend_page(child, tab_label)
}

///|
impl INotebook with fn prepend_page_menu(self, child, tab_label, menu_label) -> Int {
  self.as_notebook().prepend_page_menu(child, tab_label, menu_label)
}

///|
impl INotebook with fn prev_page(self) -> Unit {
  self.as_notebook().prev_page()
}

///|
impl INotebook with fn remove_page(self, page_num) -> Unit {
  self.as_notebook().remove_page(page_num)
}

///|
impl INotebook with fn reorder_child(self, child, position) -> Unit {
  self.as_notebook().reorder_child(child, position)
}

///|
impl INotebook with fn set_action_widget(self, widget, pack_type) -> Unit {
  self.as_notebook().set_action_widget(widget, pack_type)
}

///|
impl INotebook with fn set_current_page(self, page_num) -> Unit {
  self.as_notebook().set_current_page(page_num)
}

///|
impl INotebook with fn set_group_name(self, group_name) -> Unit {
  self.as_notebook().set_group_name(group_name)
}

///|
impl INotebook with fn set_menu_label(self, child, menu_label) -> Unit {
  self.as_notebook().set_menu_label(child, menu_label)
}

///|
impl INotebook with fn set_menu_label_text(self, child, menu_text) -> Unit {
  self.as_notebook().set_menu_label_text(child, menu_text)
}

///|
impl INotebook with fn set_scrollable(self, scrollable) -> Unit {
  self.as_notebook().set_scrollable(scrollable)
}

///|
impl INotebook with fn set_show_border(self, show_border) -> Unit {
  self.as_notebook().set_show_border(show_border)
}

///|
impl INotebook with fn set_show_tabs(self, show_tabs) -> Unit {
  self.as_notebook().set_show_tabs(show_tabs)
}

///|
impl INotebook with fn set_tab_detachable(self, child, detachable) -> Unit {
  self.as_notebook().set_tab_detachable(child, detachable)
}

///|
impl INotebook with fn set_tab_label(self, child, tab_label) -> Unit {
  self.as_notebook().set_tab_label(child, tab_label)
}

///|
impl INotebook with fn set_tab_label_text(self, child, tab_text) -> Unit {
  self.as_notebook().set_tab_label_text(child, tab_text)
}

///|
impl INotebook with fn set_tab_pos(self, pos) -> Unit {
  self.as_notebook().set_tab_pos(pos)
}

///|
impl INotebook with fn set_tab_reorderable(self, child, reorderable) -> Unit {
  self.as_notebook().set_tab_reorderable(child, reorderable)
}

///|
impl INotebook with fn connect_change_current_page(self, f) -> UInt64 {
  self.as_notebook().connect_change_current_page(f)
}

///|
impl INotebook with fn connect_focus_tab(self, f) -> UInt64 {
  self.as_notebook().connect_focus_tab(f)
}

///|
impl INotebook with fn connect_move_focus_out(self, f) -> UInt64 {
  self.as_notebook().connect_move_focus_out(f)
}

///|
impl INotebook with fn connect_page_added(self, f) -> UInt64 {
  self.as_notebook().connect_page_added(f)
}

///|
impl INotebook with fn connect_page_removed(self, f) -> UInt64 {
  self.as_notebook().connect_page_removed(f)
}

///|
impl INotebook with fn connect_page_reordered(self, f) -> UInt64 {
  self.as_notebook().connect_page_reordered(f)
}

///|
impl INotebook with fn connect_reorder_tab(self, f) -> UInt64 {
  self.as_notebook().connect_reorder_tab(f)
}

///|
impl INotebook with fn connect_select_page(self, f) -> UInt64 {
  self.as_notebook().connect_select_page(f)
}

///|
impl INotebook with fn connect_switch_page(self, f) -> UInt64 {
  self.as_notebook().connect_switch_page(f)
}

///|
pub fn Notebook::as_widget(self : Notebook) -> Widget = "%identity"

///|
pub impl IWidget for Notebook with fn as_widget(self) {
  self.as_widget()
}

///|
pub fn Notebook::as_gobject_object(self : Notebook) -> @gobject.Object = "%identity"

///|
pub impl @gobject.IObject for Notebook with fn as_object(self) {
  self.as_gobject_object()
}