warb 0.1.0

data/docs/components/reply_button_action.md

@@ -0,0 +1,32 @@
+# Interactive Reply Button Action
+
+An interactive reply button action allows you to create a set of buttons that, when clicked, send a predefined reply back to the sender.
+
+You don't need to create the buttons manually, as the `Warb::Resources::InteractiveReplyButton` class provides a convenient way to build the action with the buttons texts.
+
+The only `parameter` possible to be set is `buttons_texts`, which is an array of strings representing the texts for each button:
+
+```ruby
+action = Warb::Components::ReplyButtonAction.new(buttons_texts: ["Português", "English", "Español"])
+```
+
+and could be used like this:
+
+```ruby
+Warb.interactive_reply_button.dispatch(recipient_number, action: action) do |message|
+  # Set the header, body, and footer as needed
+end
+```
+
+You can also use the `add_button_text` method to add buttons one by one:
+
+```ruby
+action = Warb::Components::ReplyButtonAction.new
+action.add_button_text("Português")
+action.add_button_text("English")
+action.add_button_text("Español")
+```
+
+Also, note that you can only add up to 3 buttons in a single action
+
+Check the [Interactive Reply Button Message](../messages/interactive_reply_button.md) documentation for more details on how to use this action in a message.

data/docs/components/row.md

@@ -0,0 +1,13 @@
+# Row
+
+Row is a component that represents a single item in a section of an interactive list message. It is used to display an option or choice to the user.
+
+You don't need to create a row by youself, as the `Warb::Components::Section` will handle that for you.
+
+Here are its attributes:
+| Attribute   | Type   | Required | Max Length | Description                                                                 |
+|-------------|--------|----------|------------|-----------------------------------------------------------------------------|
+| title       | String | Yes      | 24         | The title of the row, which is displayed to the user                        |
+| description | String | No       | 72         | A brief description of the row, providing additional context or information |
+
+Check its usage in the [section component documentation](./section.md) or a more complete guide in the [interactive list message documentation](../messages/interactive_list.md)

data/docs/components/section.md

@@ -0,0 +1,30 @@
+# Section
+
+`Warb::Components::Section` is a component that represents a group of items of an interactive list message. It is used to display multiple options, grouped under a common title.
+
+You don't need to create a section by yourself, as the `Warb::Components::ListAction` will handle that for you.
+
+Here are its attributes:
+| Attribute | Type   | Required | Max Length                                             | Description                                    |
+|-----------|--------|----------|--------------------------------------------------------|------------------------------------------------|
+| title     | String | Yes      | 24                                                     | The title of the section                       |
+| rows      | Array  | Yes      | 10 (combining all sections within the message)         | The available options the user can choose from |
+
+The section component instance also offers a `add_row` method to add a row to the section after its creation.
+
+```ruby
+section = Warb::Components::Section.new(title: "Languages")
+
+section.add_row(title: "Português")
+section.add_row(title: "English")
+
+# or using a block
+section.add_row do |row|
+  row.title = "Español"
+  row.description = "Spanish language"
+end
+```
+
+Under the hood, it will create a [`Warb::Components::Row`](./row.md) for each item added to the section.
+
+Check its complete usage in the [interactive list message documentation](../messages/interactive_list.md)

data/docs/components/url.md

@@ -0,0 +1,40 @@
+# URL
+
+URL, `Warb::Components::URL`, is a component used in the `Contact` message type.
+
+It represents an Organization with the following fields:
+
+|Attribute | Type     | Description                                                                          | Required |
+|----------|----------|--------------------------------------------------------------------------------------|----------|
+| `url`    | `String` | Website URL associated with the contact or their company                             | No       |
+| `type`   | `String` | Type of website. For example, company, work, personal, Facebook Page, Instagram, etc | No       |
+
+When using the `Warb::Components::URL` component directly, you can set these attributes in the initializer or by assigning them directly to the instance.
+
+```ruby
+url = Warb::Components::URL.new(
+  url: "https://example.com",
+  type: "company"
+)
+```
+or
+
+```ruby
+url = Warb::Components::URL.new
+url.url = "https://example.com"
+url.type = "company"
+```
+But it is better to use it in the context of a `Contact` message type, where you can build the URL using the `add_url` method:
+
+```ruby
+Warb.contact.dispatch(recipient_number) do |contact|
+  # Adding a URL using a block
+  contact.add_url do |url|
+    url.url = "https://example.com"
+    url.type = "company"
+  end
+
+  # Adding a URL with parameters
+  contact.add_url(url: "https://personal.example.com", type: "personal")
+end
+```

data/docs/components/url_button.md

@@ -0,0 +1,57 @@
+# UrlButton
+
+`Warb::Components::UrlButton` is a component used in template messages, for dynamic url or auth code buttons.
+
+## Attributes
+|   Attribute  |    Type   | Required |                   Description                 |
+|--------------|-----------|----------|-----------------------------------------------|
+| `index`      | `Integer` |   Yes    | An identifier or position for the button.     |
+| `sub_type`   | `String`  |   Yes    | Always "url" for this button type             |
+| `text`       | `String`  |   No     | The URL suffix or text parameter for the button |
+
+## Examples
+
+### Basic URL button
+```ruby
+url_button = Warb::Components::UrlButton.new(index: 0, sub_type: "url", text: "example.com")
+url_button.to_h
+=> {
+     type: "button",
+     sub_type: "url",
+     index: 0,
+     parameters: [
+       {
+         type: "text",
+         text: "example.com"
+       }
+     ]
+   }
+```
+
+### URL button without text parameter
+```ruby
+url_button = Warb::Components::UrlButton.new(index: 1, sub_type: "url")
+url_button.to_h
+=> {
+     type: "button",
+     sub_type: "url",
+     index: 1
+   }
+```
+
+## Usage in Templates
+
+URL buttons are typically added to templates using the `add_dynamic_url_button` method:
+
+```ruby
+template = Warb::Resources::Template.new(name: "my_template", language: "en_US")
+
+# Add a dynamic URL button
+template.add_dynamic_url_button(index: 0, text: "example.com")
+
+# Or using a block for more complex configuration
+template.add_dynamic_url_button do |button|
+  button.index = 0
+  button.text = "example.com"
+end
+```

data/docs/messages/README.md

@@ -0,0 +1,80 @@
+# Messaging
+
+To send any message, you can simply call `.dispatch` from either `Warb` module or any `Warb::Client` instance (please, check the [setup](./setup.md) page for more info on how to setup your client), using the corresponding wrapper for the [message type](#messages-types) you want to send:
+
+## General Usage
+
+Basically, you can send any type of message in the same way as bellow, changing the specific params:
+
+```ruby
+Warb.<type_of_message_you_want_to_send>.dispatch(<recipient_number>, reply_to: <message_id>, **specific_params)
+```
+
+Here is what  you need to do:
+- replace `<type_of_message_you_want_to_send>` with the appropriate wrapper based on the type of message you want to send
+- replace `<recipient_number>` with the phone number of the intended recipient
+- optionally replace `<message_id>` with the ID of a previous message in the conversation if you want to send a reply to that message
+  - if you're not replying to a message, you can either set the `reply_to` parameter to `nil` or omit it entirely — `nil` is the default value
+
+Except for the `reply_to` parameter, you can pass any additional named parameters that are specific to the type of message you are sending.
+
+Such parameters are described in the documentation for each message type, which you can find in the [Messages Types](#messages-types) section below.
+
+For instance, to send a simple text message, you can:
+
+**Note**: Assume `Warb.setup` has already been called and the variable `recipient_number` is defined
+
+```ruby
+Warb.message.dispatch(recipient_number, text: "Hello from warb")
+```
+
+You can also pass a block to `.dispatch` to build the message:
+
+```ruby
+Warb.message.dispatch(recipient_number) do |message|
+  message.text = "Hello from warb"
+end
+```
+> In the example above, the variable `message` used in the block is an instance of `Warb::Resources::Text`
+
+Under the hood, the `.dispatch` method will:
+- create a message resource object, based on the used wrapper
+- set its attributes based on the parameters you provide
+- call its `build_payload` method to prepare the message for sending
+- and finally, send the message
+
+Inside the given block, you can modify modify the message before it's sent.
+
+While using a block just to set a single attribute may seem excessive — it becomes quite useful when dealing with more complex message types, such as contact or interactive messages.
+
+## Messages Types
+
+Messages are sent using a helper dispatcher and its resource class. Here is a list of available message types, their corresponding resource classes, and dispatch wrappers:
+
+| Message Type                   | Resource Class                                | Dispatch Wrapper                    | Documentation                                                                 |
+|--------------------------------|-----------------------------------------------|-------------------------------------|-------------------------------------------------------------------------------|
+| Simple Dispatchers                                                                                                                                                                                   |
+| Contact                        | `Warb::Resources::Contact`                    | `contact`                           | [Contact Message](./contact.md)                                               |
+| Interactive Call to Action URL | `Warb::Resources::InteractiveCalltoActionURL` | `interactive_call_to_action_url`    | [Interactive Call to Action URL Message](./interactive_call_to_action_url.md) |
+| Interactive List               | `Warb::Resources::InteractiveList`            | `interactive_list`                  | [Interactive List Message](./interactive_list.md)                             |
+| Interactive Reply Button       | `Warb::Resources::InteractiveReplyButton`     | `interactive_reply_button`          | [Interactive Reply Button Message](./interactive_reply_button.md)             |
+| Flow                           | `Warb::Resources::Flow`                       | `flow`                              | [Flow](./flow.md)                                                             |
+| Location                       | `Warb::Resources::Location`                   | `location`                          | [Location Message](./location.md)                                             |
+| Location Request               | `Warb::Resources::LocationRequest`            | `location_request`                  | [Location Request Message](./location_request.md)                             |
+| Reaction                       | `Warb::Resources::Reaction`                   | `reaction`                          | [Reaction Message](./reaction.md)                                             |
+| Text                           | `Warb::Resources::Text`                       | `message`                           | [Text Message](./text.md)                                                     |
+| Media Dispatchers                                                                                                                                                                                    |
+| Audio                          | `Warb::Resources::Audio`                      | `audio`                             | [Audio Message](./audio.md)                                                   |
+| Document                       | `Warb::Resources::Document`                   | `document`                          | [Document Message](./document.md)                                             |
+| Image                          | `Warb::Resources::Image`                      | `image`                             | [Image Message](./image.md)                                                   |
+| Sticker                        | `Warb::Resources::Sticker`                    | `sticker`                           | [Sticker Message](./sticker.md)                                               |
+| Video                          | `Warb::Resources::Video`                      | `video`                             | [Video Message](./video.md)                                                   |
+| Special Dispatchers                                                                                                                                                                                  |
+| Indicator                      | `Warb::Resources::Indicator`                  | `indicator`                         | [Indicator Message](./indicator.md)                                           |
+| Template                       | `Warb::Resources::Template`                   | `template`                          | [Template Message](./template.md)                                             |
+
+> Simple Dispatcher doesn't offer any additional functionality, they just send messages.
+
+> Media Dispatchers, aside from sending messages, also provide methods to upload and download media files.
+
+> Special Dispatchers are used for specific purposes, such as sending indicators, reactions or templates.

data/docs/messages/audio.md

@@ -0,0 +1,119 @@
+# Audio
+
+For starters, not all audio formats are supported by WhatsApp. Here is a table of supported audio formats:
+
+| Audio Type | Extension | MIME Type                                                                       | Max Size |
+| ---------- | --------- | ------------------------------------------------------------------------------- | -------- |
+| AAC        | `.aac`    | `audio/aac`                                                                     | 16 MB    |
+| AMR        | `.amr`    | `audio/amr`                                                                     | 16 MB    |
+| MP3        | `.mp3`    | `audio/mpeg`                                                                    | 16 MB    |
+| MP4 Audio  | `.m4a`    | `audio/mp4`                                                                     | 16 MB    |
+| OGG Audio  | `.ogg`    | `audio/ogg` (OPUS codecs only; base `audio/ogg` not supported; mono input only) | 16 MB    |
+
+To send an audio message, use the `audio` dispatch wrapper as follow:
+
+```ruby
+recipient_number = "..."
+Warb.audio.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 audio message like this:
+
+```ruby
+Warb.audio.dispatch(recipient_number, link: "https://example.com/audio.ogg")
+```
+
+You can also use the block building strategy to send an audio message:
+
+```ruby
+Warb.audio.dispatch(recipient_number) do |audio|
+  audio.link = "https://example.com/audio.ogg"
+end
+```
+
+As seen above, the `link` field is used to set the audio file URL. This must be a direct link to an audio file hosted online.
+
+Also, if using a link, the audio 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 an audio by using its ID. For that, you need to have the ID of the audio file already uploaded to WhatsApp.
+
+#### Upload
+
+Since our `audio` wrapper is a media dispatcher, it supports media related operations, like `upload` and `download` method.
+
+So, we can use the `upload` method to upload an audio file and get its ID:
+
+```ruby
+audio_id = Warb.audio.upload(file_path: "path/to/audio.ogg", file_type: "audio/ogg")
+```
+
+> `file_type` must be one of the supported audio types listed [above](#), and `file_path` is the path to the audio file you want to upload.
+
+**Note**: At this point, it is not possible to retrieve the ID of an audio file that was previously uploaded, so keep the ID returned by the `upload` method for later use.
+
+**Note**: Also, note that uploaded audio are stored in 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 Audio ID
+
+With the audio id in hands, you can use the it to send the audio message:
+
+```ruby
+Warb.audio.dispatch(recipient_number, media_id: audio_id)
+```
+You can also use the block building strategy to send an audio message with an ID:
+
+```ruby
+Warb.audio.dispatch(recipient_number) do |audio|
+  audio.media_id = audio_id
+end
+```
+
+**Note**: Either only one of the `link` or `media_id` fields can be set at a time.
+
+#### Downloading Audio
+
+You can also download an audio file using its ID:
+
+```ruby
+Warb.audio.download(media_id: audio_id, file_path: "path/to/save/audio.ogg")
+```
+
+This will download the audio file to the specified path.
+
+Under the hood, the `download` method will use `retrieve` method to get the download URL.
+
+With the URL in hands, the `download` method will, in fact, download the file to the specified path.
+
+The `retrieve` receives a single parameter, which is the `media_id` of the audio file you want to retrieve.
+
+```ruby
+Warb.audio.retrieve(media_id: audio_id)
+```
+
+And here is a sample response from the `retrieve` method:
+
+```json
+{
+  "url": "https://lookaside.fbsbx.com/...",
+  "mime_type": "audio/ogg",
+  "sha256": "4b4719...",
+  "file_size": 4799,
+  "id": "134183...",
+  "messaging_product": "whatsapp"
+}
+```
+
+#### Deleting Audio
+
+You can delete an audio file using its ID:
+
+```ruby
+Warb.audio.delete(audio_id)
+```
+
+This will delete the audio 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 audio file.

data/docs/messages/contact.md

@@ -0,0 +1,134 @@
+# Contact
+
+Send a contact using the `contact` wrapper:
+
+```ruby
+recipient_number = "..."
+Warb.contact.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 contact like this:
+```ruby
+name = Warb::Components::Name.new formatted_name: "Full Name", preffix: "Mr"
+
+Warb.contact.dispatch(recipient_number, name: name)
+```
+
+But it may be tiring writing this all, so the next example bellow shows a different approach to send the same message:
+
+```ruby
+Warb.contact.dispatch(recipient_number) do |contact|
+  contact.build_name formatted_name: "Full Name", prefix: "Mr"
+end
+```
+
+This block building strategy can be used to build even larger contacts, for exemple:
+```ruby
+Warb.contact.dispatch(recipient_number) do |contact|
+  contact.build_name formatted_name: "Full Name", prefix: "Mr"
+
+  country = "Country"
+  country_code = "Country Code"
+
+  # you can set everything inside the block
+  contact.add_address do |address|
+    address.street = "First Street"
+    address.city = "First City"
+    address.state = "First State"
+    address.zip = "First ZIP"
+    address.country = country
+    address.country_code = country_code
+    address.type = "HOME"
+  end
+
+  # you can, as well, pass some values to the add_address method
+  second_address = contact.add_address(type: "WORK") do |address|
+    address.street = "Second Street"
+    address.city = "Second City"
+    address.state = "Second State"
+    address.zip = "Second ZIP"
+  end
+
+  # and also, assign values using the returned object
+  second_address.country = country
+  second_address.country_code = country_code
+end
+```
+
+There are more fields which can be set in the contact type message. Here is a more complete example:
+
+```ruby
+Warb.contact.dispatch(recipient_number) do |contact|
+  # name (a Warb::Components::Name instance)
+  contact.build_name do |name|
+    name.formatted_name = "Full Name"
+    name.prefix = "Mr"
+    name.suffix = "IV"
+    name.first_name = "Full"
+    name.last_name = "Name"
+    name.middle_name = "Middle"
+  end
+
+  # string in the format YYYY-MM-DD
+  contact.birthday = "1980-06-06"
+
+  # addresses (a list of Warb::Components::Address)
+  country = "Country"
+  country_code = "Country Code"
+
+  contact.add_address do |address|
+    address.street = "First Street"
+    address.city = "First City"
+    address.state = "First State"
+    address.zip = "First ZIP"
+    address.country = country
+    address.country_code = country_code
+    address.type = "HOME"
+  end
+
+  contact.add_address do |address|
+    address.street = "Second Street"
+    address.city = "Second City"
+    address.state = "Second State"
+    address.zip = "Second ZIP"
+    address.country = country
+    address.country_code = country_code
+    address.type = "WORK"
+  end
+
+  # emails (a list of Warb::Components::Email)
+  contact.add_email(email: "personal@email.com", type: "HOME")
+  contact.add_email(email: "work@email.com", type: "WORK")
+
+  # urls (a list of Warb::Components::URL)
+  contact.add_url(type: "HOME", url: "https://primary.home.example.com")
+  contact.add_url(type: "HOME", url: "https://secondary.home.example.com")
+  contact.add_url(type: "WORK", url: "https://work.example.com")
+
+  # phones (a list of Warb::Components::Phone)
+  contact.add_phone(type: "HOME", phone: "...")
+  contact.add_phone(type: "HOME", phone: "...", wa_id: "...")
+  contact.add_phone(type: "WORK", phone: "...")
+
+  # org (a Warb::Components::Org instance)
+  contact.build_org do |org|
+    org.company = "Inc"
+    org.title = "Manager"
+    org.department = "IT"
+  end
+end
+```
+
+Here are the specific params which can be passed to the `dispatch` method using the `contact` wrapper:
+
+| Field       | Type / Description                               | Required | Documentation                       |
+| ----------- | ------------------------------------------------ | -------- | ----------------------------------- |
+| `name`      | A `Warb::Components::Name` instance              | YES      | [Name](../components/name.md)       |
+| `birthday`  | A `String` in the format `YYYY-MM-DD`.           | NO       | —                                   |
+| `org`       | A `Warb::Components::Org` instance               | NO       | [Org](../components/org.md)         |
+| `addresses` | A list of `Warb::Components::Address` instances  | NO       | [Address](../components/address.md) |
+| `emails`    | A list of `Warb::Components::Email` instances    | NO       | [Email](../components/email.md)     |
+| `urls`      | A list of `Warb::Components::URL` instances      | NO       | [URL](../components/url.md)         |
+| `phones`    | A list of `Warb::Components::Phone` instances    | NO       | [Phone](../components/phone.md)     |

data/docs/messages/document.md

@@ -0,0 +1,122 @@
+# Document
+
+For starters, not all documents are supported by WhatsApp. Here is a table of supported documents:
+
+| Document Type         | Extension | MIME Type                                                                   | Max Size |
+|-----------------------|-----------|-----------------------------------------------------------------------------|----------|
+| Text                  | `.txt`    | `text/plain`                                                                | 100 MB   |
+| Microsoft Excel       | `.xls`    | `application/vnd.ms-excel`                                                  | 100 MB   |
+| Microsoft Excel       | `.xlsx`   | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`         | 100 MB   |
+| Microsoft Word        | `.doc`    | `application/msword`                                                        | 100 MB   |
+| Microsoft Word        | `.docx`   | `application/vnd.openxmlformats-officedocument.wordprocessingml.document`   | 100 MB   |
+| Microsoft PowerPoint  | `.ppt`    | `application/vnd.ms-powerpoint`                                             | 100 MB   |
+| Microsoft PowerPoint  | `.pptx`   | `application/vnd.openxmlformats-officedocument.presentationml.presentation` | 100 MB   |
+| PDF                   | `.pdf`    | `application/pdf`                                                           | 100 MB   |
+
+To send a document message, use the `document` dispatch wrapper as follows:
+
+```ruby
+recipient_number = "..."
+Warb.document.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 document message like this:
+
+```ruby
+Warb.document.dispatch(recipient_number, link: "https://example.com/document.pdf")
+```
+
+You can also use the block building strategy to send a document message:
+
+```ruby
+Warb.document.dispatch(recipient_number) do |document|
+  document.link = "https://example.com/document.pdf"
+end
+```
+
+As seen above, the `link` field is used to set the document file URL. This must be a direct link to a file hosted online.
+
+Also, if using a link, the document 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 document by using its ID. For that, you need to have the ID of the document file already uploaded to WhatsApp.
+
+#### Upload
+
+Since our `document` 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 document file and get its ID:
+
+```ruby
+document_id = Warb.document.upload(file_path: "path/to/document.pdf", file_type: "application/pdf")
+```
+
+> `file_type` must be one of the supported document types listed [above](#), and `file_path` is the path to the document file you want to upload.
+
+**Note**: At this point, it is not possible to retrieve the ID of a document file that was previously uploaded, so keep the ID returned by the `upload` method for later use.
+
+**Note**: Also, note that uploaded documents 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 Document ID
+
+With the document ID in hand, you can use it to send the document message:
+
+```ruby
+Warb.document.dispatch(recipient_number, media_id: document_id)
+```
+
+You can also use the block building strategy to send a document message with an ID:
+
+```ruby
+Warb.document.dispatch(recipient_number) do |document|
+  document.media_id = document_id
+end
+```
+
+**Note**: Either only one of the `link` or `media_id` fields can be set at a time.
+
+#### Downloading Document
+
+You can also download a document file using its ID:
+
+```ruby
+Warb.document.download(media_id: document_id, file_path: "path/to/save/document.pdf")
+```
+
+This will download the document 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 document file you want to retrieve.
+
+```ruby
+Warb.document.retrieve(media_id: document_id)
+```
+
+And here is a sample response from the `retrieve` method:
+
+```json
+{
+  "url": "https://lookaside.fbsbx.com/...",
+  "mime_type": "application/pdf",
+  "sha256": "4b4719...",
+  "file_size": 1048576,
+  "id": "134183...",
+  "messaging_product": "whatsapp"
+}
+```
+
+#### Deleting Document
+
+You can delete a document file using its ID:
+
+```ruby
+Warb.document.delete(document_id)
+```
+
+This will delete the document 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 document file.

data/docs/messages/flow.md

@@ -0,0 +1,12 @@
+# Flow
+
+Flow is a special type of message. We can summarize it simply as a form.
+
+At this point of writing, this gem only supports sending existing flows, and it can only send flows which are in draft.
+
+To send flows, you can do as following:
+```ruby
+Warb.flow.dispatch(recipient_number, flow_id: "flow_id", screen: "screen")
+```
+
+`flow_id` must be the ID of the flow and `screen` must be the ID of the first screen of the flow.