slack_morphism/models/blocks/

kit.rs

use rsb_derive::Builder;
use rvstruct::ValueStruct;
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use url::Url;

use super::workflow::SlackBlockWorkflowButtonElement;
use crate::*;

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Eq, Hash, Serialize, Deserialize, ValueStruct)]
pub struct SlackBlockId(pub String);

#[derive(Debug, PartialEq, Clone, Eq, Hash, Serialize, Deserialize, ValueStruct)]
pub struct SlackTaskId(pub String);

#[derive(Debug, PartialEq, Clone, Eq, Hash, Serialize, Deserialize, ValueStruct)]
pub struct SlackAccessibilityLabel(pub String);

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackBlock {
    #[serde(rename = "section")]
    Section(SlackSectionBlock),
    #[serde(rename = "header")]
    Header(SlackHeaderBlock),
    #[serde(rename = "divider")]
    Divider(SlackDividerBlock),
    #[serde(rename = "image")]
    Image(SlackImageBlock),
    #[serde(rename = "actions")]
    Actions(SlackActionsBlock),
    #[serde(rename = "context")]
    Context(SlackContextBlock),
    #[serde(rename = "input")]
    Input(SlackInputBlock),
    #[serde(rename = "file")]
    File(SlackFileBlock),
    #[serde(rename = "video")]
    Video(SlackVideoBlock),
    #[serde(rename = "markdown")]
    Markdown(SlackMarkdownBlock),
    #[serde(rename = "rich_text")]
    RichText(SlackRichTextBlock),
    #[serde(rename = "table")]
    Table(SlackTableBlock),
    #[serde(rename = "task_card")]
    TaskCard(SlackTaskCardBlock),
    #[serde(rename = "alert")]
    Alert(SlackAlertBlock),
    #[serde(rename = "card")]
    Card(SlackCardBlock),
    #[serde(rename = "carousel")]
    Carousel(SlackCarouselBlock),
    #[serde(rename = "context_actions")]
    ContextActions(SlackContextActionsBlock),
    #[serde(rename = "share_shortcut")]
    ShareShortcut(serde_json::Value),
    #[serde(rename = "event")]
    Event(serde_json::Value),
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackSectionBlock {
    pub block_id: Option<SlackBlockId>,
    pub text: Option<SlackBlockText>,
    pub fields: Option<Vec<SlackBlockText>>,
    pub accessory: Option<SlackSectionBlockElement>,
    pub expand: Option<bool>,
}

impl From<SlackSectionBlock> for SlackBlock {
    fn from(block: SlackSectionBlock) -> Self {
        SlackBlock::Section(block)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackHeaderBlock {
    pub block_id: Option<SlackBlockId>,
    pub text: SlackBlockPlainTextOnly,
}

impl From<SlackHeaderBlock> for SlackBlock {
    fn from(block: SlackHeaderBlock) -> Self {
        SlackBlock::Header(block)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackDividerBlock {
    pub block_id: Option<SlackBlockId>,
}

impl From<SlackDividerBlock> for SlackBlock {
    fn from(block: SlackDividerBlock) -> Self {
        SlackBlock::Divider(block)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackImageBlock {
    pub block_id: Option<SlackBlockId>,
    #[serde(flatten)]
    pub image_url_or_file: SlackImageUrlOrFile,
    pub alt_text: String,
    pub title: Option<SlackBlockPlainTextOnly>,
}

impl From<SlackImageBlock> for SlackBlock {
    fn from(block: SlackImageBlock) -> Self {
        SlackBlock::Image(block)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackActionsBlock {
    pub block_id: Option<SlackBlockId>,
    pub elements: Vec<SlackActionBlockElement>,
}

impl From<SlackActionsBlock> for SlackBlock {
    fn from(block: SlackActionsBlock) -> Self {
        SlackBlock::Actions(block)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackContextBlock {
    pub block_id: Option<SlackBlockId>,
    pub elements: Vec<SlackContextBlockElement>,
}

impl From<SlackContextBlock> for SlackBlock {
    fn from(block: SlackContextBlock) -> Self {
        SlackBlock::Context(block)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackInputBlock {
    pub block_id: Option<SlackBlockId>,
    pub label: SlackBlockPlainTextOnly,
    pub element: SlackInputBlockElement,
    pub hint: Option<SlackBlockPlainTextOnly>,
    pub optional: Option<bool>,
    pub dispatch_action: Option<bool>,
}

impl From<SlackInputBlock> for SlackBlock {
    fn from(block: SlackInputBlock) -> Self {
        SlackBlock::Input(block)
    }
}

const SLACK_FILE_BLOCK_SOURCE_DEFAULT: &str = "remote";

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackFileBlock {
    pub block_id: Option<SlackBlockId>,
    pub external_id: String,
    #[default = "SLACK_FILE_BLOCK_SOURCE_DEFAULT.into()"]
    pub source: String,
}

impl From<SlackFileBlock> for SlackBlock {
    fn from(block: SlackFileBlock) -> Self {
        SlackBlock::File(block)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackSectionBlockElement {
    #[serde(rename = "image")]
    Image(SlackBlockImageElement),
    #[serde(rename = "button")]
    Button(SlackBlockButtonElement),
    #[serde(rename = "static_select")]
    StaticSelect(SlackBlockStaticSelectElement),
    #[serde(rename = "multi_static_select")]
    MultiStaticSelect(SlackBlockMultiStaticSelectElement),
    #[serde(rename = "external_select")]
    ExternalSelect(SlackBlockExternalSelectElement),
    #[serde(rename = "multi_external_select")]
    MultiExternalSelect(SlackBlockMultiExternalSelectElement),
    #[serde(rename = "users_select")]
    UsersSelect(SlackBlockUsersSelectElement),
    #[serde(rename = "multi_users_select")]
    MultiUsersSelect(SlackBlockMultiUsersSelectElement),
    #[serde(rename = "conversations_select")]
    ConversationsSelect(SlackBlockConversationsSelectElement),
    #[serde(rename = "multi_conversations_select")]
    MultiConversationsSelect(SlackBlockMultiConversationsSelectElement),
    #[serde(rename = "channels_select")]
    ChannelsSelect(SlackBlockChannelsSelectElement),
    #[serde(rename = "multi_channels_select")]
    MultiChannelsSelect(SlackBlockMultiChannelsSelectElement),
    #[serde(rename = "overflow")]
    Overflow(SlackBlockOverflowElement),
    #[serde(rename = "datepicker")]
    DatePicker(SlackBlockDatePickerElement),
    #[serde(rename = "timepicker")]
    TimePicker(SlackBlockTimePickerElement),
    #[serde(rename = "plain_text_input")]
    PlainTextInput(SlackBlockPlainTextInputElement),
    #[serde(rename = "number_input")]
    NumberInput(SlackBlockNumberInputElement),
    #[serde(rename = "url_text_input")]
    UrlInput(SlackBlockUrlInputElement),
    #[serde(rename = "radio_buttons")]
    RadioButtons(SlackBlockRadioButtonsElement),
    #[serde(rename = "checkboxes")]
    Checkboxes(SlackBlockCheckboxesElement),
    #[serde(rename = "workflow_button")]
    WorkflowButton(SlackBlockWorkflowButtonElement),
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackActionBlockElement {
    #[serde(rename = "button")]
    Button(SlackBlockButtonElement),
    #[serde(rename = "overflow")]
    Overflow(SlackBlockOverflowElement),
    #[serde(rename = "datepicker")]
    DatePicker(SlackBlockDatePickerElement),
    #[serde(rename = "timepicker")]
    TimePicker(SlackBlockTimePickerElement),
    #[serde(rename = "datetimepicker")]
    DateTimePicker(SlackBlockDateTimePickerElement),
    #[serde(rename = "plain_text_input")]
    PlainTextInput(SlackBlockPlainTextInputElement),
    #[serde(rename = "number_input")]
    NumberInput(SlackBlockNumberInputElement),
    #[serde(rename = "url_text_input")]
    UrlInput(SlackBlockUrlInputElement),
    #[serde(rename = "radio_buttons")]
    RadioButtons(SlackBlockRadioButtonsElement),
    #[serde(rename = "checkboxes")]
    Checkboxes(SlackBlockCheckboxesElement),
    #[serde(rename = "static_select")]
    StaticSelect(SlackBlockStaticSelectElement),
    #[serde(rename = "external_select")]
    ExternalSelect(SlackBlockExternalSelectElement),
    #[serde(rename = "users_select")]
    UsersSelect(SlackBlockUsersSelectElement),
    #[serde(rename = "conversations_select")]
    ConversationsSelect(SlackBlockConversationsSelectElement),
    #[serde(rename = "channels_select")]
    ChannelsSelect(SlackBlockChannelsSelectElement),
    #[serde(rename = "workflow_button")]
    WorkflowButton(SlackBlockWorkflowButtonElement),
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackContextBlockElement {
    #[serde(rename = "image")]
    Image(SlackBlockImageElement),
    #[serde(rename = "plain_text")]
    Plain(SlackBlockPlainText),
    #[serde(rename = "mrkdwn")]
    MarkDown(SlackBlockMarkDownText),
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackInputBlockElement {
    #[serde(rename = "static_select")]
    StaticSelect(SlackBlockStaticSelectElement),
    #[serde(rename = "multi_static_select")]
    MultiStaticSelect(SlackBlockMultiStaticSelectElement),
    #[serde(rename = "external_select")]
    ExternalSelect(SlackBlockExternalSelectElement),
    #[serde(rename = "multi_external_select")]
    MultiExternalSelect(SlackBlockMultiExternalSelectElement),
    #[serde(rename = "users_select")]
    UsersSelect(SlackBlockUsersSelectElement),
    #[serde(rename = "multi_users_select")]
    MultiUsersSelect(SlackBlockMultiUsersSelectElement),
    #[serde(rename = "conversations_select")]
    ConversationsSelect(SlackBlockConversationsSelectElement),
    #[serde(rename = "multi_conversations_select")]
    MultiConversationsSelect(SlackBlockMultiConversationsSelectElement),
    #[serde(rename = "channels_select")]
    ChannelsSelect(SlackBlockChannelsSelectElement),
    #[serde(rename = "multi_channels_select")]
    MultiChannelsSelect(SlackBlockMultiChannelsSelectElement),
    #[serde(rename = "datepicker")]
    DatePicker(SlackBlockDatePickerElement),
    #[serde(rename = "timepicker")]
    TimePicker(SlackBlockTimePickerElement),
    #[serde(rename = "datetimepicker")]
    DateTimePicker(SlackBlockDateTimePickerElement),
    #[serde(rename = "plain_text_input")]
    PlainTextInput(SlackBlockPlainTextInputElement),
    #[serde(rename = "number_input")]
    NumberInput(SlackBlockNumberInputElement),
    #[serde(rename = "url_text_input")]
    UrlInput(SlackBlockUrlInputElement),
    #[serde(rename = "radio_buttons")]
    RadioButtons(SlackBlockRadioButtonsElement),
    #[serde(rename = "checkboxes")]
    Checkboxes(SlackBlockCheckboxesElement),
    #[serde(rename = "email_text_input")]
    EmailInput(SlackBlockEmailInputElement),
    #[serde(rename = "rich_text_input")]
    RichTextInput(SlackBlockRichTextInputElement),
    #[serde(rename = "file_input")]
    FileInput(SlackBlockFileInputElement),
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockImageElement {
    #[serde(flatten)]
    pub image_url_or_file: SlackImageUrlOrFile,
    pub alt_text: String,
}

impl From<SlackBlockImageElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockImageElement) -> Self {
        SlackSectionBlockElement::Image(element)
    }
}

impl From<SlackBlockImageElement> for SlackContextBlockElement {
    fn from(element: SlackBlockImageElement) -> Self {
        SlackContextBlockElement::Image(element)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackBlockButtonStyle {
    Primary,
    Danger,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockButtonElement {
    pub action_id: SlackActionId,
    pub text: SlackBlockPlainTextOnly,
    pub url: Option<Url>,
    pub value: Option<String>,
    pub style: Option<SlackBlockButtonStyle>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub accessibility_label: Option<SlackAccessibilityLabel>,
}

impl From<SlackBlockButtonElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockButtonElement) -> Self {
        SlackSectionBlockElement::Button(element)
    }
}

impl From<SlackBlockButtonElement> for SlackActionBlockElement {
    fn from(element: SlackBlockButtonElement) -> Self {
        SlackActionBlockElement::Button(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockConfirmItem {
    pub title: SlackBlockPlainTextOnly,
    pub text: SlackBlockText,
    pub confirm: SlackBlockPlainTextOnly,
    pub deny: SlackBlockPlainTextOnly,
    pub style: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockChoiceItem<T: Into<SlackBlockText>> {
    pub text: T,
    pub value: String,
    pub url: Option<Url>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockOptionGroup<T: Into<SlackBlockText>> {
    pub label: SlackBlockPlainTextOnly,
    pub options: Vec<SlackBlockChoiceItem<T>>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockStaticSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub options: Option<Vec<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>>,
    pub option_groups: Option<Vec<SlackBlockOptionGroup<SlackBlockPlainTextOnly>>>,
    pub initial_option: Option<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockStaticSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockStaticSelectElement) -> Self {
        SlackSectionBlockElement::StaticSelect(element)
    }
}

impl From<SlackBlockStaticSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockStaticSelectElement) -> Self {
        SlackInputBlockElement::StaticSelect(element)
    }
}

impl From<SlackBlockStaticSelectElement> for SlackActionBlockElement {
    fn from(element: SlackBlockStaticSelectElement) -> Self {
        SlackActionBlockElement::StaticSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockMultiStaticSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub options: Option<Vec<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>>,
    pub option_groups: Option<Vec<SlackBlockOptionGroup<SlackBlockPlainTextOnly>>>,
    pub initial_options: Option<Vec<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub max_selected_items: Option<u64>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockMultiStaticSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockMultiStaticSelectElement) -> Self {
        SlackSectionBlockElement::MultiStaticSelect(element)
    }
}

impl From<SlackBlockMultiStaticSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockMultiStaticSelectElement) -> Self {
        SlackInputBlockElement::MultiStaticSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockExternalSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_option: Option<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
    pub min_query_length: Option<u64>,
}

impl From<SlackBlockExternalSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockExternalSelectElement) -> Self {
        SlackSectionBlockElement::ExternalSelect(element)
    }
}

impl From<SlackBlockExternalSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockExternalSelectElement) -> Self {
        SlackInputBlockElement::ExternalSelect(element)
    }
}

impl From<SlackBlockExternalSelectElement> for SlackActionBlockElement {
    fn from(element: SlackBlockExternalSelectElement) -> Self {
        SlackActionBlockElement::ExternalSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockMultiExternalSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_options: Option<Vec<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub max_selected_items: Option<u64>,
    pub focus_on_load: Option<bool>,
    pub min_query_length: Option<u64>,
}

impl From<SlackBlockMultiExternalSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockMultiExternalSelectElement) -> Self {
        SlackSectionBlockElement::MultiExternalSelect(element)
    }
}

impl From<SlackBlockMultiExternalSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockMultiExternalSelectElement) -> Self {
        SlackInputBlockElement::MultiExternalSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockUsersSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_user: Option<String>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockUsersSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockUsersSelectElement) -> Self {
        SlackSectionBlockElement::UsersSelect(element)
    }
}

impl From<SlackBlockUsersSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockUsersSelectElement) -> Self {
        SlackInputBlockElement::UsersSelect(element)
    }
}

impl From<SlackBlockUsersSelectElement> for SlackActionBlockElement {
    fn from(element: SlackBlockUsersSelectElement) -> Self {
        SlackActionBlockElement::UsersSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockMultiUsersSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_users: Option<Vec<String>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub max_selected_items: Option<u64>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockMultiUsersSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockMultiUsersSelectElement) -> Self {
        SlackSectionBlockElement::MultiUsersSelect(element)
    }
}

impl From<SlackBlockMultiUsersSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockMultiUsersSelectElement) -> Self {
        SlackInputBlockElement::MultiUsersSelect(element)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub enum SlackConversationFilterInclude {
    #[serde(rename = "im")]
    Im,
    #[serde(rename = "mpim")]
    Mpim,
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "private")]
    Private,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockConversationFilter {
    pub include: Option<Vec<SlackConversationFilterInclude>>,
    pub exclude_external_shared_channels: Option<bool>,
    pub exclude_bot_users: Option<bool>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockConversationsSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_conversation: Option<SlackConversationId>,
    pub default_to_current_conversation: Option<bool>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub response_url_enabled: Option<bool>,
    pub focus_on_load: Option<bool>,
    pub filter: Option<SlackBlockConversationFilter>,
}

impl From<SlackBlockConversationsSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockConversationsSelectElement) -> Self {
        SlackSectionBlockElement::ConversationsSelect(element)
    }
}

impl From<SlackBlockConversationsSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockConversationsSelectElement) -> Self {
        SlackInputBlockElement::ConversationsSelect(element)
    }
}

impl From<SlackBlockConversationsSelectElement> for SlackActionBlockElement {
    fn from(element: SlackBlockConversationsSelectElement) -> Self {
        SlackActionBlockElement::ConversationsSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockMultiConversationsSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_conversations: Option<Vec<SlackConversationId>>,
    pub default_to_current_conversation: Option<bool>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub max_selected_items: Option<u64>,
    pub focus_on_load: Option<bool>,
    pub filter: Option<SlackBlockConversationFilter>,
}

impl From<SlackBlockMultiConversationsSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockMultiConversationsSelectElement) -> Self {
        SlackSectionBlockElement::MultiConversationsSelect(element)
    }
}

impl From<SlackBlockMultiConversationsSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockMultiConversationsSelectElement) -> Self {
        SlackInputBlockElement::MultiConversationsSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockChannelsSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_channel: Option<SlackChannelId>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub response_url_enabled: Option<bool>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockChannelsSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockChannelsSelectElement) -> Self {
        SlackSectionBlockElement::ChannelsSelect(element)
    }
}

impl From<SlackBlockChannelsSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockChannelsSelectElement) -> Self {
        SlackInputBlockElement::ChannelsSelect(element)
    }
}

impl From<SlackBlockChannelsSelectElement> for SlackActionBlockElement {
    fn from(element: SlackBlockChannelsSelectElement) -> Self {
        SlackActionBlockElement::ChannelsSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockMultiChannelsSelectElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_channels: Option<Vec<SlackChannelId>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub max_selected_items: Option<u64>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockMultiChannelsSelectElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockMultiChannelsSelectElement) -> Self {
        SlackSectionBlockElement::MultiChannelsSelect(element)
    }
}

impl From<SlackBlockMultiChannelsSelectElement> for SlackInputBlockElement {
    fn from(element: SlackBlockMultiChannelsSelectElement) -> Self {
        SlackInputBlockElement::MultiChannelsSelect(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockOverflowElement {
    pub action_id: SlackActionId,
    pub options: Vec<SlackBlockChoiceItem<SlackBlockPlainTextOnly>>,
    pub confirm: Option<SlackBlockConfirmItem>,
}

impl From<SlackBlockOverflowElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockOverflowElement) -> Self {
        SlackSectionBlockElement::Overflow(element)
    }
}

impl From<SlackBlockOverflowElement> for SlackActionBlockElement {
    fn from(element: SlackBlockOverflowElement) -> Self {
        SlackActionBlockElement::Overflow(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockDatePickerElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_date: Option<String>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockDatePickerElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockDatePickerElement) -> Self {
        SlackSectionBlockElement::DatePicker(element)
    }
}

impl From<SlackBlockDatePickerElement> for SlackInputBlockElement {
    fn from(element: SlackBlockDatePickerElement) -> Self {
        SlackInputBlockElement::DatePicker(element)
    }
}

impl From<SlackBlockDatePickerElement> for SlackActionBlockElement {
    fn from(element: SlackBlockDatePickerElement) -> Self {
        SlackActionBlockElement::DatePicker(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockTimePickerElement {
    pub action_id: SlackActionId,
    pub initial_time: Option<String>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub timezone: Option<String>,
}

impl From<SlackBlockTimePickerElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockTimePickerElement) -> Self {
        SlackSectionBlockElement::TimePicker(element)
    }
}

impl From<SlackBlockTimePickerElement> for SlackInputBlockElement {
    fn from(element: SlackBlockTimePickerElement) -> Self {
        SlackInputBlockElement::TimePicker(element)
    }
}

impl From<SlackBlockTimePickerElement> for SlackActionBlockElement {
    fn from(element: SlackBlockTimePickerElement) -> Self {
        SlackActionBlockElement::TimePicker(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockDateTimePickerElement {
    pub action_id: SlackActionId,
    pub initial_date_time: Option<SlackDateTime>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockDateTimePickerElement> for SlackInputBlockElement {
    fn from(element: SlackBlockDateTimePickerElement) -> Self {
        SlackInputBlockElement::DateTimePicker(element)
    }
}

impl From<SlackBlockDateTimePickerElement> for SlackActionBlockElement {
    fn from(element: SlackBlockDateTimePickerElement) -> Self {
        SlackActionBlockElement::DateTimePicker(element)
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/composition-objects/dispatch-action-configuration-object
 */
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackDispatchActionTrigger {
    OnEnterPressed,
    OnCharacterEntered,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackDispatchActionConfig {
    pub trigger_actions_on: Option<Vec<SlackDispatchActionTrigger>>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockPlainTextInputElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_value: Option<String>,
    pub multiline: Option<bool>,
    pub min_length: Option<u64>,
    pub max_length: Option<u64>,
    pub focus_on_load: Option<bool>,
    pub dispatch_action_config: Option<SlackDispatchActionConfig>,
}

impl From<SlackBlockPlainTextInputElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockPlainTextInputElement) -> Self {
        SlackSectionBlockElement::PlainTextInput(element)
    }
}

impl From<SlackBlockPlainTextInputElement> for SlackInputBlockElement {
    fn from(element: SlackBlockPlainTextInputElement) -> Self {
        SlackInputBlockElement::PlainTextInput(element)
    }
}

impl From<SlackBlockPlainTextInputElement> for SlackActionBlockElement {
    fn from(element: SlackBlockPlainTextInputElement) -> Self {
        SlackActionBlockElement::PlainTextInput(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockNumberInputElement {
    pub action_id: SlackActionId,
    pub is_decimal_allowed: bool,
    pub focus_on_load: Option<bool>,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_value: Option<String>,
    pub min_value: Option<String>,
    pub max_value: Option<String>,
}

impl From<SlackBlockNumberInputElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockNumberInputElement) -> Self {
        SlackSectionBlockElement::NumberInput(element)
    }
}

impl From<SlackBlockNumberInputElement> for SlackInputBlockElement {
    fn from(element: SlackBlockNumberInputElement) -> Self {
        SlackInputBlockElement::NumberInput(element)
    }
}

impl From<SlackBlockNumberInputElement> for SlackActionBlockElement {
    fn from(element: SlackBlockNumberInputElement) -> Self {
        SlackActionBlockElement::NumberInput(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockUrlInputElement {
    pub action_id: SlackActionId,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_value: Option<String>,
}

impl From<SlackBlockUrlInputElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockUrlInputElement) -> Self {
        SlackSectionBlockElement::UrlInput(element)
    }
}

impl From<SlackBlockUrlInputElement> for SlackInputBlockElement {
    fn from(element: SlackBlockUrlInputElement) -> Self {
        SlackInputBlockElement::UrlInput(element)
    }
}

impl From<SlackBlockUrlInputElement> for SlackActionBlockElement {
    fn from(element: SlackBlockUrlInputElement) -> Self {
        SlackActionBlockElement::UrlInput(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockEmailInputElement {
    pub action_id: SlackActionId,
    pub focus_on_load: Option<bool>,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
    pub initial_value: Option<EmailAddress>,
}

impl From<SlackBlockEmailInputElement> for SlackInputBlockElement {
    fn from(element: SlackBlockEmailInputElement) -> Self {
        SlackInputBlockElement::EmailInput(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockRadioButtonsElement {
    pub action_id: SlackActionId,
    pub options: Vec<SlackBlockChoiceItem<SlackBlockText>>,
    pub initial_option: Option<SlackBlockChoiceItem<SlackBlockText>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockRadioButtonsElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockRadioButtonsElement) -> Self {
        SlackSectionBlockElement::RadioButtons(element)
    }
}

impl From<SlackBlockRadioButtonsElement> for SlackInputBlockElement {
    fn from(element: SlackBlockRadioButtonsElement) -> Self {
        SlackInputBlockElement::RadioButtons(element)
    }
}

impl From<SlackBlockRadioButtonsElement> for SlackActionBlockElement {
    fn from(element: SlackBlockRadioButtonsElement) -> Self {
        SlackActionBlockElement::RadioButtons(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockCheckboxesElement {
    pub action_id: SlackActionId,
    pub options: Vec<SlackBlockChoiceItem<SlackBlockText>>,
    pub initial_options: Option<Vec<SlackBlockChoiceItem<SlackBlockText>>>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub focus_on_load: Option<bool>,
}

impl From<SlackBlockCheckboxesElement> for SlackSectionBlockElement {
    fn from(element: SlackBlockCheckboxesElement) -> Self {
        SlackSectionBlockElement::Checkboxes(element)
    }
}

impl From<SlackBlockCheckboxesElement> for SlackInputBlockElement {
    fn from(element: SlackBlockCheckboxesElement) -> Self {
        SlackInputBlockElement::Checkboxes(element)
    }
}

impl From<SlackBlockCheckboxesElement> for SlackActionBlockElement {
    fn from(element: SlackBlockCheckboxesElement) -> Self {
        SlackActionBlockElement::Checkboxes(element)
    }
}

/**
 * 'plain_text' type of https://api.slack.com/reference/block-kit/composition-objects#text
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockPlainText {
    pub text: String,
    pub emoji: Option<bool>,
}

/**
 * 'mrkdwn' type of https://api.slack.com/reference/block-kit/composition-objects#text
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockMarkDownText {
    pub text: String,
    pub verbatim: Option<bool>,
}

/**
 * https://api.slack.com/reference/block-kit/composition-objects#text
 */
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackBlockText {
    #[serde(rename = "plain_text")]
    Plain(SlackBlockPlainText),
    #[serde(rename = "mrkdwn")]
    MarkDown(SlackBlockMarkDownText),
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename = "plain_text")]
pub struct SlackBlockPlainTextOnly {
    #[serde(flatten)]
    value: SlackBlockPlainText,
}

impl SlackBlockPlainText {
    pub fn as_block_text(&self) -> SlackBlockText {
        SlackBlockText::Plain(self.clone())
    }
}

impl From<String> for SlackBlockPlainText {
    fn from(value: String) -> Self {
        SlackBlockPlainText::new(value)
    }
}

impl From<&str> for SlackBlockPlainText {
    fn from(value: &str) -> Self {
        SlackBlockPlainText::new(String::from(value))
    }
}

impl SlackBlockMarkDownText {
    pub fn as_block_text(&self) -> SlackBlockText {
        SlackBlockText::MarkDown(self.clone())
    }
}

impl From<String> for SlackBlockMarkDownText {
    fn from(value: String) -> Self {
        SlackBlockMarkDownText::new(value)
    }
}

impl From<&str> for SlackBlockMarkDownText {
    fn from(value: &str) -> Self {
        SlackBlockMarkDownText::new(String::from(value))
    }
}

impl From<SlackBlockPlainText> for SlackBlockPlainTextOnly {
    fn from(pt: SlackBlockPlainText) -> Self {
        SlackBlockPlainTextOnly { value: pt }
    }
}

impl From<SlackBlockPlainText> for SlackBlockText {
    fn from(text: SlackBlockPlainText) -> Self {
        SlackBlockText::Plain(text)
    }
}

impl From<SlackBlockMarkDownText> for SlackBlockText {
    fn from(text: SlackBlockMarkDownText) -> Self {
        SlackBlockText::MarkDown(text)
    }
}

impl From<SlackBlockPlainText> for SlackContextBlockElement {
    fn from(text: SlackBlockPlainText) -> Self {
        SlackContextBlockElement::Plain(text)
    }
}

impl From<SlackBlockMarkDownText> for SlackContextBlockElement {
    fn from(text: SlackBlockMarkDownText) -> Self {
        SlackContextBlockElement::MarkDown(text)
    }
}

impl From<SlackBlockPlainTextOnly> for SlackBlockText {
    fn from(text: SlackBlockPlainTextOnly) -> Self {
        SlackBlockText::Plain(text.value)
    }
}

impl From<String> for SlackBlockPlainTextOnly {
    fn from(value: String) -> Self {
        SlackBlockPlainTextOnly {
            value: value.into(),
        }
    }
}

impl From<&str> for SlackBlockPlainTextOnly {
    fn from(value: &str) -> Self {
        SlackBlockPlainTextOnly {
            value: value.into(),
        }
    }
}

/**
 * https://api.slack.com/reference/block-kit/blocks#video
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackVideoBlock {
    pub alt_text: String,
    pub author_name: Option<String>,
    pub block_id: Option<SlackBlockId>,
    pub description: Option<SlackBlockPlainTextOnly>,
    pub provider_icon_url: Option<Url>,
    pub provider_name: Option<String>,
    pub title: SlackBlockPlainTextOnly,
    pub title_url: Option<Url>,
    pub thumbnail_url: Url,
    pub video_url: Url,
}

impl From<SlackVideoBlock> for SlackBlock {
    fn from(block: SlackVideoBlock) -> Self {
        SlackBlock::Video(block)
    }
}

/**
 * https://api.slack.com/reference/block-kit/blocks#markdown
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackMarkdownBlock {
    pub block_id: Option<SlackBlockId>,
    pub text: String,
}

impl From<SlackMarkdownBlock> for SlackBlock {
    fn from(block: SlackMarkdownBlock) -> Self {
        SlackBlock::Markdown(block)
    }
}

/**
 * https://api.slack.com/reference/block-kit/blocks#rich_text
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextBlock {
    pub block_id: Option<SlackBlockId>,
    pub elements: Vec<SlackRichTextElement>,
}

impl From<SlackRichTextBlock> for SlackBlock {
    fn from(block: SlackRichTextBlock) -> Self {
        SlackBlock::RichText(block)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum SlackRichTextInlineContent {
    #[serde(rename = "rich_text")]
    RichText(SlackRichTextBlock),
}

impl From<SlackRichTextBlock> for SlackRichTextInlineContent {
    fn from(block: SlackRichTextBlock) -> Self {
        SlackRichTextInlineContent::RichText(block)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackRichTextElement {
    #[serde(rename = "rich_text_section")]
    Section(SlackRichTextSection),
    #[serde(rename = "rich_text_list")]
    List(SlackRichTextList),
    #[serde(rename = "rich_text_preformatted")]
    Preformatted(SlackRichTextPreformatted),
    #[serde(rename = "rich_text_quote")]
    Quote(SlackRichTextQuote),
}

impl From<SlackRichTextSection> for SlackRichTextElement {
    fn from(element: SlackRichTextSection) -> Self {
        SlackRichTextElement::Section(element)
    }
}

impl From<SlackRichTextList> for SlackRichTextElement {
    fn from(list: SlackRichTextList) -> Self {
        SlackRichTextElement::List(list)
    }
}

impl From<SlackRichTextPreformatted> for SlackRichTextElement {
    fn from(element: SlackRichTextPreformatted) -> Self {
        SlackRichTextElement::Preformatted(element)
    }
}

impl From<SlackRichTextQuote> for SlackRichTextElement {
    fn from(element: SlackRichTextQuote) -> Self {
        SlackRichTextElement::Quote(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextSection {
    pub elements: Vec<SlackRichTextInlineElement>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextList {
    pub style: SlackRichTextListStyle,
    pub elements: Vec<SlackRichTextListElement>,
    pub indent: Option<u64>,
    pub offset: Option<u64>,
    pub border: Option<u64>,
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackRichTextListElement {
    #[serde(rename = "rich_text_section")]
    Section(SlackRichTextSection),
}

impl From<SlackRichTextSection> for SlackRichTextListElement {
    fn from(element: SlackRichTextSection) -> Self {
        SlackRichTextListElement::Section(element)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackRichTextListStyle {
    Bullet,
    Ordered,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextPreformatted {
    pub elements: Vec<SlackRichTextInlineElement>,
    pub border: Option<u64>,
    pub language: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextQuote {
    pub elements: Vec<SlackRichTextInlineElement>,
    pub border: Option<u64>,
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackRichTextInlineElement {
    #[serde(rename = "text")]
    Text(SlackRichTextText),
    #[serde(rename = "link")]
    Link(SlackRichTextLink),
    #[serde(rename = "user")]
    User(SlackRichTextUser),
    #[serde(rename = "channel")]
    Channel(SlackRichTextChannel),
    #[serde(rename = "usergroup")]
    UserGroup(SlackRichTextUserGroup),
    #[serde(rename = "emoji")]
    Emoji(SlackRichTextEmoji),
    #[serde(rename = "date")]
    Date(SlackRichTextDate),
    #[serde(rename = "broadcast")]
    Broadcast(SlackRichTextBroadcast),
    #[serde(rename = "color")]
    Color(SlackRichTextColor),
    #[serde(rename = "message_mention")]
    MessageMention(SlackRichTextMessageMention),
    #[serde(untagged)]
    Unknown(serde_json::Value),
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextStyle {
    pub bold: Option<bool>,
    pub italic: Option<bool>,
    pub strike: Option<bool>,
    pub code: Option<bool>,
    pub underline: Option<bool>,
    pub highlight: Option<bool>,
    pub client_highlight: Option<bool>,
    pub unlink: Option<bool>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextText {
    pub text: String,
    pub style: Option<SlackRichTextStyle>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextLink {
    pub url: SlackRelaxedUrl,
    pub text: Option<String>,
    #[serde(rename = "unsafe")]
    pub unsafe_: Option<bool>,
    pub style: Option<SlackRichTextStyle>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextUser {
    pub user_id: SlackUserId,
    pub style: Option<SlackRichTextStyle>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextChannel {
    pub channel_id: SlackChannelId,
    pub style: Option<SlackRichTextStyle>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextUserGroup {
    pub usergroup_id: SlackUserGroupId,
    pub style: Option<SlackRichTextStyle>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextEmoji {
    pub name: SlackEmojiName,
    pub unicode: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextDate {
    pub timestamp: SlackDateTime,
    pub format: String,
    pub fallback: Option<String>,
    pub style: Option<SlackRichTextStyle>,
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackRichTextBroadcastRange {
    Here,
    Channel,
    Everyone,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextBroadcast {
    pub range: SlackRichTextBroadcastRange,
    pub style: Option<SlackRichTextStyle>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextColor {
    pub value: String,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackRichTextMessageMention {
    pub url: SlackRelaxedUrl,
    pub text: Option<String>,
    pub channel_id: Option<SlackChannelId>,
    pub author_id: Option<SlackUserId>,
    pub message_ts: Option<SlackTs>,
    pub thread_ts: Option<SlackTs>,
    pub style: Option<SlackRichTextStyle>,
}

/**
 * https://api.slack.com/reference/block-kit/block-elements#rich_text_input
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockRichTextInputElement {
    pub action_id: SlackActionId,
    pub initial_value: Option<SlackRichTextBlock>,
    pub focus_on_load: Option<bool>,
    pub placeholder: Option<SlackBlockPlainTextOnly>,
}

impl From<SlackBlockRichTextInputElement> for SlackInputBlockElement {
    fn from(element: SlackBlockRichTextInputElement) -> Self {
        SlackInputBlockElement::RichTextInput(element)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SlackImageUrlOrFile {
    ImageUrl { image_url: Url },
    SlackFile { slack_file: SlackFileIdOrUrl },
}

impl SlackImageUrlOrFile {
    pub fn image_url(&self) -> Option<&Url> {
        match self {
            SlackImageUrlOrFile::ImageUrl { image_url } => Some(image_url),
            SlackImageUrlOrFile::SlackFile { slack_file } => match slack_file {
                SlackFileIdOrUrl::Url { url } => Some(url),
                _ => None,
            },
        }
    }
}

impl From<Url> for SlackImageUrlOrFile {
    fn from(value: Url) -> Self {
        SlackImageUrlOrFile::ImageUrl { image_url: value }
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SlackFileIdOrUrl {
    Id { id: SlackFileId },
    Url { url: Url },
}

impl From<SlackFileId> for SlackFileIdOrUrl {
    fn from(value: SlackFileId) -> Self {
        SlackFileIdOrUrl::Id { id: value }
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/blocks/table-block
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackTableBlock {
    pub block_id: Option<SlackBlockId>,
    pub rows: Vec<Vec<SlackTableCell>>,
    pub column_settings: Option<Vec<SlackTableColumnSetting>>,
}

impl From<SlackTableBlock> for SlackBlock {
    fn from(block: SlackTableBlock) -> Self {
        SlackBlock::Table(block)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackTableCell {
    #[serde(rename = "raw_text")]
    RawText(SlackTableRawTextCell),
    #[serde(rename = "rich_text")]
    RichText(SlackTableRichTextCell),
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackTableRawTextCell {
    pub text: String,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackTableRichTextCell {
    pub elements: Vec<SlackRichTextElement>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackTableColumnSetting {
    pub align: Option<SlackTableColumnAlign>,
    pub is_wrapped: Option<bool>,
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackTableColumnAlign {
    Left,
    Center,
    Right,
}

/**
 * https://docs.slack.dev/reference/block-kit/blocks/task-card-block
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackTaskCardBlock {
    pub task_id: SlackTaskId,
    pub title: String,
    pub block_id: Option<SlackBlockId>,
    pub status: Option<SlackTaskCardStatus>,
    #[serde(rename = "details")]
    pub details: Option<SlackRichTextInlineContent>,
    #[serde(rename = "output")]
    pub output: Option<SlackRichTextInlineContent>,
    pub sources: Option<Vec<SlackTaskCardSource>>,
}

impl From<SlackTaskCardBlock> for SlackBlock {
    fn from(block: SlackTaskCardBlock) -> Self {
        SlackBlock::TaskCard(block)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackTaskCardStatus {
    Pending,
    InProgress,
    Complete,
    Error,
}

/**
 * https://docs.slack.dev/reference/block-kit/block-elements/url-source-element
 */
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackUrlSourceElement {
    pub url: Url,
    pub text: String,
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackTaskCardSource {
    #[serde(rename = "url")]
    Url(SlackUrlSourceElement),
}

impl From<SlackUrlSourceElement> for SlackTaskCardSource {
    fn from(element: SlackUrlSourceElement) -> Self {
        SlackTaskCardSource::Url(element)
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/block-elements/file-input-element
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockFileInputElement {
    pub action_id: SlackActionId,
    pub filetypes: Option<Vec<String>>,
    pub max_files: Option<u64>,
}

impl From<SlackBlockFileInputElement> for SlackInputBlockElement {
    fn from(element: SlackBlockFileInputElement) -> Self {
        SlackInputBlockElement::FileInput(element)
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/blocks/alert-block
 */
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SlackAlertLevel {
    Warning,
    Error,
    Info,
    Success,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackAlertBlock {
    pub block_id: Option<SlackBlockId>,
    pub text: SlackBlockText,
    pub level: Option<SlackAlertLevel>,
}

impl From<SlackAlertBlock> for SlackBlock {
    fn from(block: SlackAlertBlock) -> Self {
        SlackBlock::Alert(block)
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/blocks/card-block
 */
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackCardImageElement {
    #[serde(rename = "image")]
    Image(SlackBlockImageElement),
}

impl From<SlackBlockImageElement> for SlackCardImageElement {
    fn from(element: SlackBlockImageElement) -> Self {
        SlackCardImageElement::Image(element)
    }
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackCardActionBlockElement {
    #[serde(rename = "button")]
    Button(SlackBlockButtonElement),
}

impl From<SlackBlockButtonElement> for SlackCardActionBlockElement {
    fn from(element: SlackBlockButtonElement) -> Self {
        SlackCardActionBlockElement::Button(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackCardBlock {
    pub block_id: Option<SlackBlockId>,
    pub title: Option<SlackBlockText>,
    pub subtitle: Option<SlackBlockText>,
    pub body: Option<SlackBlockText>,
    pub hero_image: Option<SlackCardImageElement>,
    pub icon: Option<SlackCardImageElement>,
    pub actions: Option<Vec<SlackCardActionBlockElement>>,
}

impl From<SlackCardBlock> for SlackBlock {
    fn from(block: SlackCardBlock) -> Self {
        SlackBlock::Card(block)
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/blocks/carousel-block
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackCarouselBlock {
    pub block_id: Option<SlackBlockId>,
    pub elements: Vec<SlackBlock>,
}

impl From<SlackCarouselBlock> for SlackBlock {
    fn from(block: SlackCarouselBlock) -> Self {
        SlackBlock::Carousel(block)
    }
}

/**
 * https://docs.slack.dev/reference/block-kit/blocks/context-actions-block
 * https://docs.slack.dev/reference/block-kit/block-elements/feedback-buttons-element
 * https://docs.slack.dev/reference/block-kit/block-elements/icon-button-element
 */
#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackFeedbackButtonItem {
    pub action_id: SlackActionId,
    pub value: String,
    pub text: SlackBlockPlainTextOnly,
    pub confirm: Option<SlackBlockConfirmItem>,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockFeedbackButtonsElement {
    pub action_id: SlackActionId,
    pub positive: SlackFeedbackButtonItem,
    pub negative: SlackFeedbackButtonItem,
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackBlockIconButtonElement {
    pub action_id: SlackActionId,
    pub icon: String,
    pub text: SlackBlockPlainTextOnly,
    pub value: Option<String>,
    pub confirm: Option<SlackBlockConfirmItem>,
    pub accessibility_label: Option<SlackAccessibilityLabel>,
    pub visible_to_user_ids: Option<Vec<SlackUserId>>,
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SlackContextActionBlockElement {
    #[serde(rename = "feedback_buttons")]
    FeedbackButtons(SlackBlockFeedbackButtonsElement),
    #[serde(rename = "icon_button")]
    IconButton(SlackBlockIconButtonElement),
}

impl From<SlackBlockFeedbackButtonsElement> for SlackContextActionBlockElement {
    fn from(element: SlackBlockFeedbackButtonsElement) -> Self {
        SlackContextActionBlockElement::FeedbackButtons(element)
    }
}

impl From<SlackBlockIconButtonElement> for SlackContextActionBlockElement {
    fn from(element: SlackBlockIconButtonElement) -> Self {
        SlackContextActionBlockElement::IconButton(element)
    }
}

#[skip_serializing_none]
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
pub struct SlackContextActionsBlock {
    pub block_id: Option<SlackBlockId>,
    pub elements: Vec<SlackContextActionBlockElement>,
}

impl From<SlackContextActionsBlock> for SlackBlock {
    fn from(block: SlackContextActionsBlock) -> Self {
        SlackBlock::ContextActions(block)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::blocks::SlackHomeView;

    #[test]
    fn test_conversation_filter_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_conversations_select_with_filter.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        match block {
            SlackBlock::Section(section) => match section.accessory {
                Some(SlackSectionBlockElement::ConversationsSelect(elem)) => {
                    let filter = elem.filter.expect("filter should be present");
                    let include = filter.include.expect("include should be present");
                    assert_eq!(include.len(), 2);
                    assert_eq!(include[0], SlackConversationFilterInclude::Public);
                    assert_eq!(include[1], SlackConversationFilterInclude::Private);
                    assert_eq!(filter.exclude_external_shared_channels, Some(true));
                    assert_eq!(filter.exclude_bot_users, Some(true));
                }
                _ => panic!("Expected ConversationsSelect accessory"),
            },
            _ => panic!("Expected Section block"),
        }
        Ok(())
    }

    #[test]
    fn test_conversation_filter_serialize() -> Result<(), Box<dyn std::error::Error>> {
        let filter = SlackBlockConversationFilter::new()
            .with_include(vec![
                SlackConversationFilterInclude::Im,
                SlackConversationFilterInclude::Mpim,
            ])
            .with_exclude_bot_users(true);

        let json = serde_json::to_value(&filter)?;
        assert_eq!(
            json,
            serde_json::json!({
                "include": ["im", "mpim"],
                "exclude_bot_users": true
            })
        );
        Ok(())
    }

    #[test]
    fn test_conversation_filter_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let elem = SlackBlockConversationsSelectElement::new(SlackActionId("test_action".into()))
            .with_filter(
                SlackBlockConversationFilter::new()
                    .with_include(vec![SlackConversationFilterInclude::Public])
                    .with_exclude_external_shared_channels(true),
            );

        let json = serde_json::to_string(&elem)?;
        let parsed: SlackBlockConversationsSelectElement = serde_json::from_str(&json)?;
        assert_eq!(elem, parsed);
        Ok(())
    }

    #[test]
    fn test_multi_conversations_select_filter() -> Result<(), Box<dyn std::error::Error>> {
        let elem =
            SlackBlockMultiConversationsSelectElement::new(SlackActionId("multi_action".into()))
                .with_filter(
                    SlackBlockConversationFilter::new()
                        .with_include(vec![
                            SlackConversationFilterInclude::Public,
                            SlackConversationFilterInclude::Private,
                        ])
                        .with_exclude_bot_users(true),
                );

        let json = serde_json::to_string(&elem)?;
        let parsed: SlackBlockMultiConversationsSelectElement = serde_json::from_str(&json)?;
        assert_eq!(elem, parsed);
        Ok(())
    }

    #[test]
    fn test_conversation_filter_none_omitted() -> Result<(), Box<dyn std::error::Error>> {
        let elem = SlackBlockConversationsSelectElement::new(SlackActionId("no_filter".into()));

        let json = serde_json::to_value(&elem)?;
        assert!(json.get("filter").is_none());
        Ok(())
    }

    #[test]
    fn test_slack_image_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_image_blocks.json");
        let content: SlackMessageContent = serde_json::from_str(payload)?;
        let blocks = content.blocks.expect("Blocks should not be empty");
        match blocks.first() {
            Some(SlackBlock::Section(section)) => match &section.accessory {
                Some(SlackSectionBlockElement::Image(image)) => {
                    assert_eq!(image.alt_text, "alt text for image");
                    match &image.image_url_or_file {
                        SlackImageUrlOrFile::ImageUrl { image_url } => {
                            assert_eq!(image_url.as_str(), "https://s3-media3.fl.yelpcdn.com/bphoto/c7ed05m9lC2EmA3Aruue7A/o.jpg");
                        }
                        SlackImageUrlOrFile::SlackFile { slack_file } => {
                            panic!("Expected an image URL, not a Slack file: {:?}", slack_file);
                        }
                    }
                }
                _ => panic!("Expected a section block with an image accessory"),
            },
            _ => panic!("Expected a section block"),
        }
        Ok(())
    }

    #[test]
    fn test_rich_text_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_rich_text_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;

        let rich = match block {
            SlackBlock::RichText(r) => r,
            _ => panic!("Expected a RichText block"),
        };

        assert_eq!(rich.block_id, Some(SlackBlockId("test_block".into())));
        assert_eq!(rich.elements.len(), 4);

        // section
        let section = match &rich.elements[0] {
            SlackRichTextElement::Section(s) => s,
            _ => panic!("Expected a Section element"),
        };
        assert_eq!(section.elements.len(), 7);

        // bold text
        let text = match &section.elements[0] {
            SlackRichTextInlineElement::Text(t) => t,
            _ => panic!("Expected a Text element"),
        };
        assert_eq!(text.text, "Hello ");
        assert_eq!(text.style.as_ref().and_then(|s| s.bold), Some(true));

        // user
        assert!(matches!(
            &section.elements[1],
            SlackRichTextInlineElement::User(_)
        ));

        // emoji — name should deserialize as SlackEmojiName
        let emoji = match &section.elements[4] {
            SlackRichTextInlineElement::Emoji(e) => e,
            _ => panic!("Expected an Emoji element"),
        };
        assert_eq!(emoji.name, SlackEmojiName::new("wave".into()));

        // list
        let list = match &rich.elements[1] {
            SlackRichTextElement::List(l) => l,
            _ => panic!("Expected a List element"),
        };
        assert_eq!(list.style, SlackRichTextListStyle::Bullet);
        assert_eq!(list.elements.len(), 2);

        // list items are SlackRichTextElement::Section
        assert!(matches!(
            &list.elements[0],
            SlackRichTextListElement::Section(_)
        ));
        assert!(matches!(
            &list.elements[1],
            SlackRichTextListElement::Section(_)
        ));

        // preformatted
        assert!(matches!(
            &rich.elements[2],
            SlackRichTextElement::Preformatted(_)
        ));

        // quote
        assert!(matches!(&rich.elements[3], SlackRichTextElement::Quote(_)));

        Ok(())
    }

    #[test]
    fn test_rich_text_block_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_rich_text_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_slack_table_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_table_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;

        let table = match block {
            SlackBlock::Table(t) => t,
            _ => panic!("Expected a Table block"),
        };

        assert_eq!(table.block_id, Some(SlackBlockId("table_block_1".into())));
        assert_eq!(table.rows.len(), 2);
        assert_eq!(table.rows[0].len(), 2);

        // first row, first cell is raw_text
        match &table.rows[0][0] {
            SlackTableCell::RawText(c) => assert_eq!(c.text, "Header A"),
            _ => panic!("Expected RawText cell"),
        }

        // second row, second cell is rich_text
        match &table.rows[1][1] {
            SlackTableCell::RichText(c) => assert_eq!(c.elements.len(), 1),
            _ => panic!("Expected RichText cell"),
        }

        let settings = table
            .column_settings
            .expect("column_settings should be present");
        assert_eq!(settings.len(), 2);
        assert_eq!(settings[0].is_wrapped, Some(true));
        assert_eq!(settings[1].align, Some(SlackTableColumnAlign::Right));

        Ok(())
    }

    #[test]
    fn test_slack_table_block_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_table_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_slack_task_card_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_task_card_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;

        let task_card = match block {
            SlackBlock::TaskCard(t) => t,
            _ => panic!("Expected a TaskCard block"),
        };

        assert_eq!(task_card.task_id, SlackTaskId("task_1".into()));
        assert_eq!(task_card.title, "Fetching weather data");
        assert_eq!(
            task_card.block_id,
            Some(SlackBlockId("task_card_block_1".into()))
        );
        assert_eq!(task_card.status, Some(SlackTaskCardStatus::InProgress));

        let output = task_card.output.expect("output should be present");
        let output_block = match output {
            SlackRichTextInlineContent::RichText(b) => b,
        };
        assert_eq!(output_block.elements.len(), 1);

        let sources = task_card.sources.expect("sources should be present");
        assert_eq!(sources.len(), 2);
        match &sources[0] {
            SlackTaskCardSource::Url(u) => assert_eq!(u.text, "weather.com"),
        }

        Ok(())
    }

    #[test]
    fn test_slack_task_card_block_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_task_card_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_slack_alert_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_alert_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        match block {
            SlackBlock::Alert(alert) => {
                assert_eq!(alert.level, Some(SlackAlertLevel::Warning));
            }
            _ => panic!("Expected Alert block"),
        }
        Ok(())
    }

    #[test]
    fn test_slack_alert_block_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_alert_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_slack_card_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_card_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        match block {
            SlackBlock::Card(card) => {
                assert!(card.hero_image.is_some());
                assert!(card.actions.is_some());
                let actions = card.actions.unwrap();
                assert_eq!(actions.len(), 1);
                match &actions[0] {
                    SlackCardActionBlockElement::Button(btn) => {
                        assert_eq!(btn.style, Some(SlackBlockButtonStyle::Primary));
                    }
                }
            }
            _ => panic!("Expected Card block"),
        }
        Ok(())
    }

    #[test]
    fn test_slack_card_block_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_card_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_slack_context_actions_block_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_context_actions_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        match block {
            SlackBlock::ContextActions(ctx) => {
                assert_eq!(ctx.elements.len(), 1);
                match &ctx.elements[0] {
                    SlackContextActionBlockElement::IconButton(btn) => {
                        assert_eq!(btn.icon, "trash");
                    }
                    _ => panic!("Expected IconButton element"),
                }
            }
            _ => panic!("Expected ContextActions block"),
        }
        Ok(())
    }

    #[test]
    fn test_slack_context_actions_block_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_context_actions_block.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_slack_workflow_button_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_workflow_button.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        match block {
            SlackBlock::Actions(actions) => {
                assert_eq!(actions.elements.len(), 1);
                match &actions.elements[0] {
                    SlackActionBlockElement::WorkflowButton(btn) => {
                        assert_eq!(btn.style, Some(SlackBlockButtonStyle::Primary));
                        let params = btn
                            .workflow
                            .trigger
                            .customizable_input_parameters
                            .as_ref()
                            .expect("params should be present");
                        assert_eq!(params.len(), 1);
                        assert_eq!(params[0].name, "user_input");
                    }
                    _ => panic!("Expected WorkflowButton element"),
                }
            }
            _ => panic!("Expected Actions block"),
        }
        Ok(())
    }

    #[test]
    fn test_slack_workflow_button_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let payload = include_str!("./fixtures/slack_workflow_button.json");
        let block: SlackBlock = serde_json::from_str(payload)?;
        let serialized = serde_json::to_string(&block)?;
        let block2: SlackBlock = serde_json::from_str(&serialized)?;
        assert_eq!(block, block2);
        Ok(())
    }

    #[test]
    fn test_rich_text_message_mention_deserialize() -> Result<(), Box<dyn std::error::Error>> {
        let payload = serde_json::json!({
            "type": "rich_text",
            "block_id": "msgm1",
            "elements": [
                {
                    "type": "rich_text_section",
                    "elements": [
                        {
                            "type": "message_mention",
                            "url": "https://acme.slack.com/archives/C12345678/p1784153496441789?thread_ts=1784153496.441789&cid=C12345678",
                            "text": "a message",
                            "channel_id": "C12345678",
                            "author_id": "U12345678",
                            "message_ts": "1784153496.441789",
                            "thread_ts": "1784153496.441789"
                        }
                    ]
                }
            ]
        })
        .to_string();
        let block: SlackBlock = serde_json::from_str(&payload)?;
        match block {
            SlackBlock::RichText(rich_text) => match &rich_text.elements[0] {
                SlackRichTextElement::Section(section) => match &section.elements[0] {
                    SlackRichTextInlineElement::MessageMention(mention) => {
                        assert_eq!(mention.channel_id, Some(SlackChannelId("C12345678".into())));
                        assert_eq!(mention.author_id, Some(SlackUserId("U12345678".into())));
                        assert_eq!(
                            mention.message_ts,
                            Some(SlackTs("1784153496.441789".into()))
                        );
                    }
                    other => panic!("Expected MessageMention element, got {other:?}"),
                },
                _ => panic!("Expected Section element"),
            },
            _ => panic!("Expected RichText block"),
        }
        Ok(())
    }

    #[test]
    fn test_rich_text_unknown_inline_element_deserialize() -> Result<(), Box<dyn std::error::Error>>
    {
        let payload = serde_json::json!({
            "type": "rich_text_section",
            "elements": [
                {
                    "type": "some_future_element",
                    "foo": "bar"
                }
            ]
        })
        .to_string();
        let section: SlackRichTextElement = serde_json::from_str(&payload)?;
        match section {
            SlackRichTextElement::Section(section) => match &section.elements[0] {
                SlackRichTextInlineElement::Unknown(value) => {
                    assert_eq!(value["type"], "some_future_element");
                }
                other => panic!("Expected Unknown element, got {other:?}"),
            },
            _ => panic!("Expected Section element"),
        }
        Ok(())
    }
}