Create a boolean callback data configuration. Useful for toggle buttons, settings, or yes/no choices.

Example

let toggle_callback = keyboard.bool_callback_data("notifications")
let enable_btn = keyboard.pack_callback(toggle_callback, True)
let disable_btn = keyboard.pack_callback(toggle_callback, False)

let assert Ok(enable) = keyboard.inline_button("🔔 Enable", enable_btn)
let assert Ok(disable) = keyboard.inline_button("🔕 Disable", disable_btn)

// In your callback handler:
let assert Ok(unpacked) = keyboard.unpack_callback(payload, toggle_callback)
case unpacked.data {
  True -> // enable notifications
  False -> // disable notifications
}

Build the final keyboard from the builder.

Create a new keyboard builder for method chaining. This provides a more ergonomic API for building complex keyboards.

Example

let keyboard = keyboard.builder()
  |> keyboard.text("Option 1")
  |> keyboard.text("Option 2")
  |> keyboard.next_row()
  |> keyboard.text("Cancel")
  |> keyboard.build()

Create a new keyboard button

Create a button that requests a chat to be shared

Add a contact request button to the current row of the keyboard builder.

Create a button that requests the user’s contact information. When pressed, the user will be prompted to share their phone number.

Example

let contact_btn = keyboard.contact_button("📞 Share Contact")
let keyboard = keyboard.single(contact_btn)

Create a filter for inline keyboard callback queries. This filter can be used with telega.wait_callback_query() to only listen for callbacks from buttons in this specific keyboard.

Example

let callback_data = keyboard.string_callback_data("action")
let assert Ok(button1) = keyboard.inline_button("Yes",
  keyboard.pack_callback(callback_data, "yes"))
let assert Ok(button2) = keyboard.inline_button("No",
  keyboard.pack_callback(callback_data, "no"))

let keyboard = keyboard.new_inline([[button1, button2]])
let assert Ok(filter) = keyboard.filter_inline_keyboard_query(keyboard)

// In your handler:
use ctx, payload, query_id <- telega.wait_callback_query(
  ctx:, filter:, or: None, timeout: None
)
let assert Ok(callback) = keyboard.unpack_callback(payload, callback_data)

Errors

• Returns Error if the keyboard has no callback buttons
• Returns Error if the callback data creates an invalid regex pattern

Create a grid keyboard with buttons arranged in rows of specified width. This is useful for creating organized layouts with many buttons.

Example

let buttons = [
  keyboard.button("1"), keyboard.button("2"), keyboard.button("3"),
  keyboard.button("4"), keyboard.button("5"), keyboard.button("6"),
]
let grid_keyboard = keyboard.grid(buttons, 3) // 3 columns per row
// Results in: [[1, 2, 3], [4, 5, 6]]

Extract button texts from a keyboard for use with telega.wait_hears(). This is useful for listening to button presses in conversation flows.

Example

let keyboard = keyboard.new([[keyboard.button("Yes"), keyboard.button("No")]])
let hears = keyboard.hear(keyboard)

use _, text <- telega.wait_hears(ctx:, hears:, or: None, timeout: None)
case text {
  "Yes" -> // handle yes
  "No" -> // handle no
  _ -> // handle other
}

Build the final inline keyboard from the builder.

Create a new inline keyboard builder for method chaining. This provides a more ergonomic API for building complex inline keyboards.

Example

let callback_data = keyboard.string_callback_data("action")
let keyboard = keyboard.inline_builder()
  |> keyboard.inline_text("Button 1", keyboard.pack_callback(callback_data, "btn1"))
  |> keyboard.inline_text("Button 2", keyboard.pack_callback(callback_data, "btn2"))
  |> keyboard.inline_next_row()
  |> keyboard.inline_url("Visit", "https://example.com")
  |> keyboard.inline_build()

Create a new inline button with callback data

Add an inline copy text button to the current row.

Create an inline copy text button

Create a grid inline keyboard with buttons arranged in rows of specified width

Start a new row in the inline keyboard builder.

Create an inline keyboard row from a list of buttons

Create a single-button inline keyboard

Add an inline switch query button to the current row.

Create an inline switch query button

Create an inline switch query current chat button

Add an inline text button with callback data to the current row.

Build a reply markup for Message from an inline keyboard

Add an inline URL button to the current row.

Create an inline URL button

Add an inline web app button to the current row.

Create an inline web app button

Create an integer callback data configuration. Useful for pagination, user IDs, or any numeric data.

Example

let page_callback = keyboard.int_callback_data("page")
let next_page = keyboard.pack_callback(page_callback, 2)
let assert Ok(button) = keyboard.inline_button("Next →", next_page)

// In your callback handler:
let assert Ok(unpacked) = keyboard.unpack_callback(payload, page_callback)
let page_number = unpacked.data // Int

Add a location request button to the current row of the keyboard builder.

Create a button that requests the user’s location. When pressed, the user will be prompted to share their current location.

Example

let location_btn = keyboard.location_button("📍 Share Location")
let keyboard = keyboard.single(location_btn)

Create a new reply keyboard from a list of button rows.

Example

let keyboard = keyboard.new([
  [keyboard.button("Yes"), keyboard.button("No")],
  [keyboard.button("Cancel")],
])

Create a new callback data configuration for inline keyboard buttons. This defines how data is serialized/deserialized when buttons are pressed.

Parameters

• id: Unique identifier for this callback type
• serialize: Function to convert your data to a string
• deserialize: Function to convert string back to your data

Example

// For custom enum types
pub type Action {
  Save
  Delete
  Edit
}

let action_callback = keyboard.new_callback_data(
  id: "action",
  serialize: fn(action) {
    case action {
      Save -> "save"
      Delete -> "delete"
      Edit -> "edit"
    }
  },
  deserialize: fn(str) {
    case str {
      "save" -> Save
      "delete" -> Delete
      _ -> Edit
    }
  }
)

Create a new inline keyboard from a list of button rows. Inline keyboards appear directly below messages and don’t replace the user’s keyboard.

Example

let callback_data = keyboard.string_callback_data("action")
let assert Ok(callback_btn) = keyboard.inline_button("Click",
  keyboard.pack_callback(callback_data, "click"))

let keyboard = keyboard.new_inline([
  [callback_btn, keyboard.inline_url_button("Visit", "https://example.com")],
  [keyboard.inline_copy_text_button("Copy", "Hello World!")],
])

Start a new row in the keyboard builder.

Make the keyboard one-time

Pack callback data into a callback

Make the keyboard persistent

Set the placeholder for the input field

Create a button that requests poll creation

Remove keyboard markup - useful for hiding keyboards

Make the keyboard resizable

Create a keyboard row from a list of buttons

Make the keyboard selective. Use this parameter if you want to show the keyboard to specific users only.

Change the delimiter for the callback data, useful if you need to use : in the id

Create a single-button keyboard

Create a simple string callback data configuration. This is the most common type for simple string-based callbacks.

Example

let callback_data = keyboard.string_callback_data("action")
let callback = keyboard.pack_callback(callback_data, "delete_user")
let assert Ok(button) = keyboard.inline_button("Delete", callback)

// In your callback handler:
let assert Ok(unpacked) = keyboard.unpack_callback(payload, callback_data)
case unpacked.data {
  "delete_user" -> // handle deletion
  _ -> // handle other actions
}

Add a text button to the current row of the keyboard builder.

Build a reply markup for Message from an inline keyboard

Build a reply markup for Message from a keyboard

Unpack payload into a callback

Create a button that requests users to be shared

Add a web app button to the current row of the keyboard builder.

Create a new web app button