warb 0.1.0

data/docs/messages/template.md

@@ -0,0 +1,327 @@
+# Template
+
+Template messages are used to send a message with a specific template.
+
+This is useful for sending messages that have a predefined structure, such as notifications or alerts.
+
+#### Quick Examples
+
+**Note**: For the examples below, take into account `Warb.setup` was called to configure the global client instance.
+
+List available templates:
+```ruby
+Warb.template.list
+```
+
+Sending template messages:
+```ruby
+Warb.template.dispatch(recipient_number, **params)
+```
+
+#### Listing Templates
+
+**Prerequisites**: In order to view templates, you need to have them available in your business account. For more details, refer to the [Meta documentation](https://developers.facebook.com/docs/whatsapp/cloud-api/guides/send-message-templates/template-library). Template creation via API will be covered later in this documentation (coming soon).
+
+You can retrieve all available message templates:
+
+```ruby
+Warb.template.list
+```
+
+##### Optional Parameters
+
+You can optionally filter templates using various parameters:
+
+Limit the number of results:
+```ruby
+Warb.template.list(limit: 10)
+```
+
+Specify which template fields to return:
+```ruby
+Warb.template.list(fields: ["name", "status", "category"])
+```
+
+For a complete list of available fields, refer to the [Meta documentation](https://developers.facebook.com/docs/graph-api/reference/whats-app-business-hsm/#fields).
+
+##### Example Response
+
+```ruby
+{
+  "data" => [
+    {
+      "name" => "hello_world",
+      "status" => "APPROVED",
+      "category" => "UTILITY",
+      "language" => "en_US",
+      "components" => [ ... ],
+      "id" => "1282952826730729"
+    },
+    {
+      "name" => "other_template_001",
+      "status" => "APPROVED",
+      "category" => "MARKETING",
+      "language" => "pt_BR",
+      "components" => [ ... ],
+      "id" => "1948352829250167"
+    }
+  ],
+  "paging" => {
+    "cursors" => {
+      "before" => "...",
+      "after" => "..."
+    }
+  }
+}
+```
+
+#### Sending Template Messages
+
+To send  a template message, you need to provide the template name and the parameters for the template, if any.
+
+```ruby
+Warb.template.dispatch(recipient_number, **params)
+```
+
+Here, `**params` is a named hash parameters that will be passed to the template, as follow:
+| Attribute   | Type              | Required | Description                           |
+|-------------|-------------------|----------|---------------------------------------|
+| `name`      | `String`          | Yes      | The name of the template to use       |
+| `language`  | `String`          | Yes      | The language to use for the template  |
+| `resources` | `Array` or `Hash` | No       | The resources to use for the template |
+
+`name` must be the name of a template that has been created in the WhatsApp Business Platform.
+
+`language` must be a valid language code, such as `en_US` for English (United States) or `fr_FR` for French (France). Also, the specified template must support the specified language.
+
+> You can check `Warb::Language` for a list of supported languages.
+> If yours isn't there, you can refer to this [list with all supported languages](https://developers.facebook.com/docs/whatsapp/business-management-api/message-templates/supported-languages) by WhatsApp.
+> Just use the value in the `code` column, and it will work.
+
+`resouces` can be an array or a hash of resources that will be used as parameters for the template. At this point, only `text`, `date_time` and `currency` are supported.
+
+If the template uses named parameters, then `resources` must be a hash, as follow:
+```ruby
+customer_name = Warb::Resources::Text.new(content: "Name")
+purchase_date = Warb::Resources::Text.new("January 1, 2023")
+
+Warb.template.dispatch(recipient_number, resources: {
+  customer_name: customer_name,
+  purchase_date: purchase_date
+}, name: "testing", language: "pt_BR")
+```
+
+If the template uses positional parameters, then `resources` must be an array, as follow:
+```ruby
+customer_name = Warb::Resources::Text.new(content: "Name")
+purchase_date = Warb::Resources::DateTime.new("January 1, 2023")
+
+Warb.template.dispatch(recipient_number, resources: [
+  customer_name,
+  purchase_date
+], name: "testing", language: "en_US")
+```
+
+In any case, under the hood, the resources instances' method `build_template_named_parameter` or `build_template_positional_parameter` will be called to build the template parameters accordingly.
+
+Instead of instatiating the resources manually, you can use helper methods as follow:
+```ruby
+Warb.template.dispatch(recipient_number) do |template|
+  template.name = "testing"
+  template.language = Warb::Language::PORTUGUESE_BR
+  template.add_text_parameter(content: "Name")
+  template.add_currency_parameter(code: "USD", amount: 11.42)
+end
+```
+
+Here, `add_text_parameter` and `add_currency_parameter` will build the resources for you with the given named parameters and add them to the template.
+
+Here's a table with all the helper methods you can use to add resources/paramters to the template message:
+| Method Name                     | Resource Type               | Description                                      |
+|---------------------------------|-----------------------------|--------------------------------------------------|
+| `add_text_parameter`            | `Warb::Resources::Text`     | Adds a text parameter to the template            |
+| `add_date_time_parameter`       | `Warb::Resources::DateTime` | Adds a date time parameter to the template       |
+| `add_currency_parameter`        | `Warb::Resources::Currency` | Adds a currency parameter to the template        |
+
+In the example above, notice we only used named parameters (no positional parameters) as arguments to the add parameter methods.
+
+So, the parameters will be built as positional parameters, and the `resources` will be an array.
+
+Also, the resources will be used to substitute the corresponding parameters in your template, in the same order they were added to the parameters/resources list.
+
+If you don't want to worry about the order of the parameters, you may use named parameters.
+
+For that, you have to pass the parameter name (as defined in your template) as the first argument to the helper method, as follow:
+```ruby
+Warb.template.dispatch(recipient_number, name: "testing", language: "pt_BR") do |template|
+  template.add_text_parameter("customer_name", content: "Name")
+  template.add_date_time_parameter("purchase_date", date_time: "January 1, 2023")
+end
+```
+
+This way, the order of the parameters names in the template and the order they were added with the `add_parameter` methods may be entirely different.
+
+One **IMPORTANT** thing to note is that, once defined, the type of the parameters won't be changed.
+
+So, in the following code:
+```ruby
+Warb.template.dispatch(recipient_number, name: "testing", language: "pt_BR") do |template|
+  template.add_date_time_parameter(date_time: "January 1, 2023")
+  template.add_text_parameter("customer_name", content: "Name")
+end
+```
+Your `customer_name` parameter won't behave the way you may expect.
+
+Since the first call to an `add_parameter` method was using the positional parameters syntax, then the internal resources attribute was set to an array, so that means any posterior calls to any `add_parameter` method will simply ignore the named parameter syntax and append the built resource to the list of positional parameters
+
+If the order of the calls was different:
+```ruby
+Warb.template.dispatch(recipient_number, name: "testing", language: "pt_BR") do |template|
+  template.add_text_parameter("customer_name", content: "Name")
+  template.add_date_time_parameter(date_time: "January 1, 2023")
+  template.add_currency_parameter(code: "USD", amount: 10)
+end
+```
+
+1. The first call to `add_parameter` method would set the internal resources/parameter to a hash, with a initial key named `customer_name`, pointing to a text resource
+
+2. Then the `DateTime` resource (built in the second call to `add_parameter` method) would be set as value to the key `""` (empty string) in the named parameter hash.
+
+3. Eventually, the `Currency` resource (in the third call do `add_parameter` method) would be set as value to the same key `""` (empty string) as the previous call, which would overwrite the previous resource.
+
+In this case, the call to the api would result in an error, either due to the mismatch of the count of parameters, or due to not having all named parameters defined.
+
+So, make sure to always use the same parameter syntax accordingly to your template.
+
+The add parameter methods also support block building as well:
+```ruby
+Warb.template.dispatch(recipient_number) do |template|
+  template.name = "testing"
+  template.language = Warb::Language::ENGLISH_US
+
+  template.add_text_parameter(content: "Name")
+
+  template.add_currency_parameter do |currency|
+    currency.code = "USD"
+    currency.amount = 11.42
+    currency.fallback = "$ 11.42"
+  end
+
+  template.add_date_time_parameter do |purchase_date|
+    purchase_date.date_time = "Jan 1st, 2024"
+  end
+end
+```
+
+If your template has any media header, you can set it as follow:
+| Header Type    | Template Instance Method    | Params                                         |
+|----------------|-----------------------------|------------------------------------------------|
+| `image`        | `set_image_header`          | `media_id` or `link`                           |
+| `video`        | `set_video_header`          | `media_id` or `link`                           |
+| `document`     | `set_document_header`       | `media_id` or `link`, `filename`               |
+| `location`     | `set_location_header`       | `latitude`, `longitude`, `name`, and `address` |
+| `text`         | `set_text_header`           | `content`, `parameter_name`                    |
+
+Every time a call is made to any `set_header` method, a new header will be set, overwriting the previous one.
+
+If you just want to change one attribute or another, `set_header` methods return the related resource, so it is possible to set the values if you keep a hold of such instance
+```ruby
+Warb.template.dispatch(recipient_number) do |template|
+  header = template.set_image_header(media_id: "wrong_media_id")
+
+  header.media_id = "correct_media_id"
+end
+```
+
+Also, either only one of `media_id` or `link` must be provided.
+
+The `media_id` must be the id of media uploaded previously to WhatsApp Business Platform, while the `link` must be a public acessible URL.
+
+Check the `upload` section for each media related message, like [`image`](./image.md) or [`document`](./document.md), for more info on how to upload and the supported formats.
+
+For the `document` header, `filename` is important because its extension will determine the preview capability on the recipient's device.
+
+For the `location` header, at least `latitude` and `longitude` must be provided.
+
+`set_header` methods will simply instatiate the corresponding resource class with the given parameters, and then, set it as the header attribute.
+
+For `text` header, note that, due to how the WhatsApp Business Platform works, you can't set the entire content for it (the same that happens with the body of the message).
+
+In this case, `set_text_header`, will simply use whatever was given to it as parameter to build the final header in the WhatsApp Business Platform.
+
+So, for example, if your tamplate header was created with `Hello, {{1}}!`, then the text passed to `set_text_header` will simply be substituted in that `{{1}}`.
+
+If your template was defined using named parameters instead (something like `Hello, {{customer_name}}!`), then you must pass the name of the paramter to `set_text_header` as follow:
+```ruby
+Warb.template.dispatch(recipient_number) do |template|
+  template.set_text_header(content: "John", parameter_name: "customer_name")
+end
+```
+
+When the template instance's `build_payload` method is called (which happens when the message is about to be dispatched), the header param will be created using the `header`'s `build_header` method.
+
+#### Adding Buttons
+
+If your template supports buttons, you can add them using the following methods:
+
+| Button Type        | Template Instance Method      | Params                                    |
+|--------------------|-------------------------------|-------------------------------------------|
+| `quick_reply`      | `add_quick_reply_button`      | `index`                                   |
+| `url`              | `add_dynamic_url_button`      | `index`, `text`                           |
+| `url`              | `add_auth_code_button`        | `index`, `text`                           |
+| `copy_code`        | `add_copy_code_button`        | `index`, `coupon_code`                    |
+| `voice_call`       | `add_voice_call_button`       | `index`                                   |
+| `doesn't apply`    | `add_button`                  | `instance`, `&block`                      |
+
+You can either use the keyword parameters or set the attributes using a block:
+
+```ruby
+Warb.template.dispatch(recipient_number) do |template|
+  template.name = "order_confirmation"
+  template.language = Warb::Language::ENGLISH_US
+
+  # Add a quick reply button
+  template.add_quick_reply_button
+
+  # Add a dynamic URL button
+  template.add_dynamic_url_button do |button|
+    button.text = "dynamic-url-suffix"
+  end
+
+  # Add a copy auth code button
+  template.add_auth_code_button do |button|
+    button.text = "4UTHC0D3"
+  end
+
+  # Add a copy code button
+  template.add_copy_code_button(index: 2) do |button|
+    button.coupon_code = "SAVE20"
+  end
+
+  # Add a voice call button
+  template.add_voice_call_button
+end
+```
+
+or if you'd rather to, you can add buttons using it's component and the `add_button` method:
+
+```ruby
+quick_reply_btn = Warb::Components::QuickReplyButton.new
+
+Warb.template.dispatch(recipient_number) do |template|
+  template.name = "order_confirmation"
+  template.language = Warb::Language::ENGLISH_US
+
+  # Add a quick reply button
+  template.add_button(quick_reply_btn)
+
+ # Add a quick reply button, passing a block.
+  template.add_button(quick_reply_btn) { |button| button.index = 1 }
+end
+```
+
+**Note**: The `index` parameter determines the order of the buttons in the template. Make sure the
+indices match the button positions defined in your template. The `index` is automaticaly set if you
+don't do it manually, but it is done based on the number of buttons added with the methods above,
+so if your template has a button that doesn't need configuration like the static url button you'll
+have provide the position of the other buttons.

data/docs/messages/text.md

@@ -0,0 +1,47 @@
+# Text
+
+Send a simple text message using the `text` wrapper:
+
+```ruby
+recipient_number = "..."
+Warb.message.dispatch(recipient_number, ...)
+```
+
+**Note**: For the examples below, take into account `Warb.setup` was called to configure the global client instance, and that the variable `recipient_number` is already set.
+
+You can send a simple text message like this:
+
+```ruby
+Warb.message.dispatch(recipient_number, content: "Hello, World!")
+```
+
+You can also use the block building strategy to send a text message:
+
+```ruby
+Warb.message.dispatch(recipient_number) do |text|
+  text.content = "Hey, check this out! https://www.google.com"
+  text.preview_url = true
+end
+```
+
+> If `preview_url` is set to `true`, the recipient WhatsApp phone/computer will try to generate a preview for the URL in the content.
+
+| Field         | Type    | Description                                                                 | Required                                 |
+|---------------|---------|-----------------------------------------------------------------------------|------------------------------------------|
+| `preview_url` | Boolean | Whether to generate a preview for URLs in the content. Defaults to `false`. | No                                       |
+| `content`     | String  | The text content of the message.                                            | Yes *                                      |
+| `text`        | String  | The text content of the message.                                            | Yes *                                      |
+| `message`     | String  | The text content of the message.                                            | Yes *                                      |
+
+> `content`, `text`, and `message` are interchangeable, you can use any of them to set the text content of the message.
+> But if using multiple of them, the priority is: `content` > `text` > `message`.
+
+Also, remember that you can use `reply_to` to reply to a previous message:
+
+```ruby
+Warb.message.dispatch(recipient_number, content: "Hello, World!", reply_to: "message_id")
+```
+
+Since text messages are the most common to be sent as replies, we're reforcing the use of `reply_to` here in the `text` wrapper. But keep in mind it can used for any other message type, like `image`, `video`, `document`, etc.
+
+**Remember**: it is a param for the `dispatch` method, not a field of the message itself.

data/docs/messages/video.md

@@ -0,0 +1,116 @@
+# Video
+
+For starters, not all video formats are supported by WhatsApp. Here is a table of supported video formats:
+
+| Video Type | Extension | MIME Type    | Max Size |
+|------------|-----------|--------------|----------|
+| MP4        | `.mp4`    | `video/mp4`  | 16 MB    |
+| 3GPP       | `.3gp`    | `video/3gpp` | 16 MB    |
+
+To send a video message, use the `video` dispatch wrapper as follows:
+
+```ruby
+recipient_number = "..."
+Warb.video.dispatch(recipient_number, ...)
+```
+
+**Note**: For the examples below, take into account `Warb.setup` was called to configure the global client instance, and that the variable `recipient_number` is already set.
+
+You can send a simple video message like this:
+
+```ruby
+Warb.video.dispatch(recipient_number, link: "https://example.com/video.mp4")
+```
+
+You can also use the block building strategy to send a video message:
+
+```ruby
+Warb.video.dispatch(recipient_number) do |video|
+  video.link = "https://example.com/video.mp4"
+end
+```
+
+As seen above, the `link` field is used to set the video file URL. This must be a direct link to a video file hosted online.
+
+Also, if using a link, the video file must be publicly accessible, meaning it should not require any authentication or special permissions to access.
+
+Aside from a link, you can also send a video by using its ID. For that, you need to have the ID of the video file already uploaded to WhatsApp.
+
+#### Upload
+
+Since our `video` wrapper is a media dispatcher, it supports media-related operations, like `upload` and `download` methods.
+
+So, we can use the `upload` method to upload a video file and get its ID:
+
+```ruby
+video_id = Warb.video.upload(file_path: "path/to/video.mp4", file_type: "video/mp4")
+```
+
+> `file_type` must be one of the supported video types listed [above](#), and `file_path` is the path to the video file you want to upload.
+
+**Note**: At this point, it is not possible to retrieve the ID of a video file that was previously uploaded, so keep the ID returned by the `upload` method for later use.
+
+**Note**: Also, note that uploaded videos are stored on WhatsApp servers for 30 days. After that period, they will be deleted and you won't be able to use the ID anymore.
+
+#### Sending with Video ID
+
+With the video ID in hand, you can use it to send the video message:
+
+```ruby
+Warb.video.dispatch(recipient_number, media_id: video_id)
+```
+
+You can also use the block building strategy to send a video message with an ID:
+
+```ruby
+Warb.video.dispatch(recipient_number) do |video|
+  video.media_id = video_id
+end
+```
+
+**Note**: Either only one of the `link` or `media_id` fields can be set at a time.
+
+#### Downloading Video
+
+You can also download a video file using its ID:
+
+```ruby
+Warb.video.download(media_id: video_id, file_path: "path/to/save/video.mp4")
+```
+
+This will download the video file to the specified path.
+
+Under the hood, the `download` method will use the `retrieve` method to get the download URL.
+
+With the URL in hand, the `download` method will, in fact, download the file to the specified path.
+
+The `retrieve` method receives a single parameter, which is the `media_id` of the video file you want to retrieve.
+
+```ruby
+Warb.video.retrieve(media_id: video_id)
+```
+
+And here is a sample response from the `retrieve` method:
+
+```json
+{
+  "url": "https://lookaside.fbsbx.com/...",
+  "mime_type": "video/mp4",
+  "sha256": "4b4719...",
+  "file_size": 1048576,
+  "id": "134183...",
+  "messaging_product": "whatsapp"
+}
+```
+
+#### Deleting Video
+
+You can delete a video file using its ID:
+
+```ruby
+Warb.video.delete(video_id)
+```
+
+This will delete the video file from WhatsApp servers and return `true` on success.
+
+This is useful if you want to free up space or if you no longer need the video file.

data/docs/resources/currency.md

@@ -0,0 +1,22 @@
+# Currency
+
+`Warb::Resources::Currency` is a resource, but different from most other resources, it can't be sent. Instead, it's used in a template message as one of its parameters.
+
+Please, refer to  our [templates messaging documentation](../messages/template.md) for more info.
+
+It represents an amount in a specific currency, which can be set with the following attributes:
+| Attribute  | Type               | Required | Description                                                 |
+|------------|--------------------|----------|-------------------------------------------------------------|
+| `amount`   | `Integer`, `Float` | Yes      | The amount to be represented in the given currency          |
+| `code`     | `String`           | Yes      | The code of the currency to be used                         |
+| `fallback` | `String`           | No       | A fallback value to be used in case the code can't be found |
+
+Since it is used in template messages, it implements both `build_template_named_parameter` and `build_template_positional_parameter`, which prepares the resource for using as parameter.
+
+If no `fallback` value is given, then a default one, based on the given `amount` and `currency` is used.
+
+In the WhatsApp Business Platform, the `code` will be used to represent the given `amount` according to the specific currency.
+
+But if the given code doesn't exist, or is not supported, then the given `fallback` value will be used instead.
+
+For the `code`, you must use one currency code like `USD` or `BRL`. `Warb::Resources::Currency` offers some of the most used currencies. You can also [check here](https://www.iso.org/iso-4217-currency-codes.html) for more detailed info and other available options.

data/docs/resources/date_time.md

@@ -0,0 +1,11 @@
+# Date Time
+
+`Warb::Resources::DateTime` is a resource, but different from most other resources, it can't be sent. Instead, it's used in a template message as one of its parameters.
+
+Please, refer to  our [templates messaging documentation](../messages/template.md) for more info.
+
+It simply represents a date time object, with the unique param/attribute being `date_time`.
+
+Although its name is `date_time`, its content can be any string, like `"January 1st"`, `"2020-01-01"` or `"Wednesday, Jan, 1st, 2020"`.
+
+Since it is used in template messages, it implements both `build_template_named_parameter` and `build_template_positional_parameter`, which prepares the resource for using as parameter.

data/docs/resources/index.md

@@ -0,0 +1,14 @@
+# Resources
+
+Most of the resources can be sent as message. Check the [messages](../messages/index.md) for detailed info.
+
+But there are some resources which act more like a component, not being used alone by themself.
+
+There are also, resources which can be used alone, and as components for other messages types, like the `Text` resource.
+
+Such resources, and where they are used, are listed bellow:
+| Resource                    | Documentation                | Used at                                                                              |
+|-----------------------------|------------------------------|--------------------------------------------------------------------------------------|
+| `Warb::Resources::Currency` | [Currency](./currency.md)    | [Template Messaging](../messages/template.md)                                        |
+| `Warb::Resources::DateTime` | [Date Time](./date_time.md)  | [Template Messaging](../messages/template.md)                                        |
+| `Warb::Resources::Text`     | [Text](./text.md)            | [Text Messaging](../messages/text.md), [Template Messaging](../messages/template.md) |

data/docs/resources/text.md

@@ -0,0 +1,9 @@
+# Text
+
+`Warb::Resources::Text` is a resource, which represents a text.
+
+It can be used as a [simple message](../messages/text.md), as a text header for some interactive messages, like the [reply button message](../messages/interactive_reply_button.md) and as [parameters for templates](../messages/template.md) variables.
+
+In the [text messaging documentation](../messages/text.md) there is a table with the corresponding attributes.
+
+Aside from such attributes, `Text` resource also provides the `build_template_named_parameter` and `build_template_positional_parameter` methods, which are using under the hood for the template messaging feature.

data/docs/setup.md

@@ -0,0 +1,46 @@
+# Setup
+
+## Global
+You can configure `Warb` globally as follow:
+
+```ruby
+Warb.setup do |config|
+  config.access_token = "access_token"
+  config.sender_id = "sender_id"
+end
+```
+
+This way, every time you use any method from Warb, like `Warb.message` or `Warb.audio`, the global configuration is going to be used automatically.
+
+So if you're running a Rails Application, you can put this code in an initializer file, like `config/initializers/warb.rb`.
+
+If you're not using Rails, you can put it in your main application file, like `app.rb` or `main.rb`.
+
+
+## Local
+
+Instead of using the global configuration, you might want to use a different configuration for a specific task. In such cases, it's possible to instatiate a client directly using `Warb.new`:
+
+```ruby
+client = Warb.new(access_token: "access_token", sender_id: "sender_id")
+client.message.dispatch(...)
+```
+
+Also, it is possible to reuse the global configuration but override some of the parameters, like `sender_id`:
+
+```ruby
+client = Warb.new(sender_id: "another_id")
+# This client will use the global `access_token` but a different `sender_id`
+client.message.dispatch(...)
+```
+
+Aside from the `access_token` and `sender_id`, you can also pass any other parameter that is supported by the `Warb::Client` class, a logger, or a custom HTTP client.
+
+```ruby
+Warb.setup do |config|
+  config.logger = Logger.new($stdout) # or any other logger you prefer
+  config.adapter = :net_http # or any other HTTP client adapter you prefer
+end
+```
+
+Also, note that calling `Warb.setup` multiple times **WILL NOT** override the previous configuration, so you can use it to change the global configuration at any time.

data/docs/webhook.md

@@ -0,0 +1,24 @@
+# Webhook
+
+You need to setup a webhook to receive messages from WhatsApp. The webhook is a URL that WhatsApp will call whenever there is an event related to your WhatsApp Business Account, such as receiving a message or a status update.
+
+Such status or updates include:
+- New Messages
+- Message delivery status
+- Message read status
+- Message reaction
+- Message template status
+- Message interactive list response
+- Message interactive reply button response
+- Errors responses
+
+To set up a webhook, follow these steps:
+1. **Create a Webhook URL**: This is the URL that WhatsApp will call to send you updates. It should be publicly accessible and able to handle POST requests.
+2. **Configure the Webhook in WhatsApp**: Go to your WhatsApp Business Account settings and configure the webhook URL. You will need to provide the URL and select the events you want to receive.
+3. **Handle Incoming Webhook Requests**: In your application, you need to create an endpoint that can handle incoming POST requests from WhatsApp. This endpoint should parse the incoming data and respond with a 200 OK status to acknowledge receipt of the message.
+4. **Verify the Webhook**: WhatsApp will send a verification request to your webhook URL. You need to respond with the `hub.challenge` parameter to verify that you own the webhook URL.
+5. **Test the Webhook**: Send a test message to your WhatsApp Business Account to ensure that your webhook is working correctly and that you are receiving updates as expected.
+
+After configuring the webhook in the WhatsApp Business Account settings, for a quick start, you can refer to [webhook.rb example](../examples/webhook.rb) to see how to handle incoming webhook requests in your application.
+
+Or you can refer to the official [Webhook Setup](https://developers.facebook.com/docs/whatsapp/cloud-api/guides/set-up-webhooks) or [Webhook payload structure](https://developers.facebook.com/docs/whatsapp/cloud-api/webhooks/components) for more details.