Skip to content

Enumeration

This section shows all the enumerations used in the API.

Channel

Channel defines the supported types of channel.

enum Channel{
  WHATSAPP = 'whatsapp',
  TELEGRAM = 'telegram',
  SMS = 'sms',
  EMAIL = 'email',
}

type Channel string

const (
    Whatsapp Channel = "whatsapp"
    Telegram Channel = "telegram"
    Sms      Channel = "sms"
    Email    Channel = "email"
)

#[derive(serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Channel {
    Whatsapp,
    Telegram,
    Sms,
    Email,
}

impl From<Channel> for String {
    fn from(val: Channel) -> String {
        match &val {
            Channel::Whatsapp => "whatsapp",
            Channel::Telegram => "telegram",
            Channel::Sms => "sms",
            Channel::Email => "email",
        }
        .into()
    }
}

impl AsRef<str> for Channel {
    fn as_ref(&self) -> &str {
        match &self {
            Channel::Whatsapp => "whatsapp",
            Channel::Telegram => "telegram",
            Channel::Sms => "sms",
            Channel::Email => "email",
        }
    }
}

Provider

Channel defines the supported types of channel's providers.

export enum Provider {
  ULTRAMSG = 'ultramsg',
  CLOUDAPI = 'cloudapi',
  TELEGRAM = 'telegram',
  TELEGRAM_GATEWAY = 'telegram_gateway',
  SMS_C = 'sms_c',
  SMS_AERO = 'sms_aero',
  SMTP = 'smtp',
  WAAPI = 'waapi',
  POSTAL = 'postal',
}

type Provider string

const (
    UltraMSG        Provider = "ultramsg"
    CloudAPI        Provider = "cloudapi"
    TelegramBot     Provider = "telegram"
    TelegramGateway Provider = "telegram_gateway"
    SmsC            Provider = "sms_c"
    SmsAero         Provider = "sms_aero"
    Smtp            Provider = "smtp"
    Waapi           Provider = "waapi"
    Postal          Provider = "postal"
)

#[derive(serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Provider {
    UltraMSG,
    CloudAPI,
    Telegram,
    TelegramGateway,
    SmsC,
    SmsAero,
    Smtp,
    Waapi,
    Postal,
}

impl From<Provider> for String {
    fn from(val: Provider) -> String {
        match &val {
            Provider::UltraMSG => "ultramsg",
            Provider::CloudAPI => "cloudapi",
            Provider::Telegram => "telegram",
            Provider::TelegramGateway => "telegram_gateway",
            Provider::SmsC => "sms_c",
            Provider::SmsAero => "sms_aero",
            Provider::Smtp => "smtp",
            Provider::Waapi => "waapi",
            Provider::Postal => "postal",
        }
        .into()
    }
}

impl AsRef<str> for Provider {
    fn as_ref(&self) -> &str {
        match &self {
            Provider::UltraMSG => "ultramsg",
            Provider::CloudAPI => "cloudapi",
            Provider::Telegram => "telegram",
            Provider::TelegramGateway => "telegram_gateway",
            Provider::SmsC => "sms_c",
            Provider::SmsAero => "sms_aero",
            Provider::Smtp => "smtp",
            Provider::Waapi => "waapi",
            Provider::Postal => "postal",
        }
    }
}

MessageStatus

MessageStatus defines the supported message statuses.

enum MessageStatus{
  SUCCESS = 'success',
  ERROR = 'error',
  PENDING = 'pending',
}

type MessageStatus string

const (
    Success MessageStatus = "success"
    Error   MessageStatus = "error"
    Pending MessageStatus = "pending"
)

#[derive(serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum MessageStatus {
    Success,
    Error,
    Pending,
}

impl From<MessageStatus> for String {
    fn from(val: MessageStatus) -> String {
        match &val {
            MessageStatus::Success => "success",
            MessageStatus::Error => "error",
            MessageStatus::Pending => "pending",
        }
        .into()
    }
}

impl AsRef<str> for MessageStatus {
    fn as_ref(&self) -> &str {
        match &self {
            MessageStatus::Success => "success",
            MessageStatus::Error => "error",
            MessageStatus::Pending => "pending",
        }
    }
}

ChallengeProvider

ChallengeProvider defines the supported types of challenge providers.

enum ChallengeProvider{
  CLOUDFLARE = 'cloudflare',
  GOOGLE = 'google',
  YANDEX = 'yandex',
  GOOGLE_V3 = 'google_v3',
}

type ChallengeProvider string

const (
    CloudFlare ChallengeProvider = "cloudflare"
    Google     ChallengeProvider = "google"
    GoogleV3   ChallengeProvider = "google_v3"
    Yandex     ChallengeProvider = "yandex"
)

#[derive(serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ChallengeProvider {
    CloudFlare,
    Google,
    GoogleV3,
    Yandex,
}

impl From<ChallengeProvider> for String {
    fn from(val: ChallengeProvider) -> String {
        match &val {
            ChallengeProvider::CloudFlare => "cloudflare",
            ChallengeProvider::Google => "google"
            ChallengeProvider::GoogleV3 => "google_v3",
            ChallengeProvider::Yandex => "yandex",
        }
        .into()
    }
}

impl AsRef<str> for ChallengeProvider {
    fn as_ref(&self) -> &str {
        match &self {
            ChallengeProvider::CloudFlare => "cloudflare",
            ChallengeProvider::Google => "google",
            ChallengeProvider::GoogleV3 => "google_v3",
            ChallengeProvider::Yandex => "yandex",
        }
    }
}

ErrorSysName

ErrorSysName defines the supported types for kod.mobi errors.

export enum ErrorEnum {
  TECHNICAL_WORK = 'TECHNICAL_WORK',
  ERROR_PROJECT_HAS_NO_CHANNELS = 'ERROR_PROJECT_HAS_NO_CHANNELS',
  ERROR_PROJECT_HAS_NO_CHANNEL = 'ERROR_PROJECT_HAS_NO_CHANNEL',
  ERROR_USER_NOT_AUTHORIZE_ON_CHANNEL = 'ERROR_USER_NOT_AUTHORIZE_ON_CHANNEL',
  ERROR_SESSION_EXPIRED = 'ERROR_SESSION_EXPIRED',
  ERROR_MESSAGE_WRONG_CODE = 'ERROR_MESSAGE_WRONG_CODE',
  ERROR_INVALID_VERIFY_TOKEN = 'ERROR_INVALID_VERIFY_TOKEN',
  ERROR_CHANNEL_NOT_ALLOWED_COUNTRY = 'ERROR_CHANNEL_NOT_ALLOWED_COUNTRY',
  ERROR_MESSAGE_ATTEMPT = 'ERROR_MESSAGE_ATTEMPT',
  ERROR_PHONE_BLOCKED = 'ERROR_PHONE_BLOCKED',
  ERROR_BLOCKED = 'ERROR_BLOCKED',
  ERROR_CHALLENGE = 'ERROR_CHALLENGE',
  ERROR_BAD_REQUEST = 'ERROR_BAD_REQUEST',
  ERROR_WRONG_BALANCE = 'ERROR_WRONG_BALANCE',
  ERROR_ACCESS_DENIED = 'ERROR_ACCESS_DENIED',
  ERROR_REQUEST_LIMIT_REACHED = 'ERROR_REQUEST_LIMIT_REACHED',
  ERROR_MESSAGE_NOT_FOUND = 'ERROR_MESSAGE_NOT_FOUND',
}

type ErrorEnum string

const (
    TechnicalWork                  ErrorEnum = "TECHNICAL_WORK"
    ErrorProjectHasNoChannels      ErrorEnum = "ERROR_PROJECT_HAS_NO_CHANNELS"
    ErrorProjectHasNoChannel       ErrorEnum = "ERROR_PROJECT_HAS_NO_CHANNEL"
    ErrorUserNotAuthorizeOnChannel ErrorEnum = "ERROR_USER_NOT_AUTHORIZE_ON_CHANNEL"
    ErrorSessionExpired            ErrorEnum = "ERROR_SESSION_EXPIRED"
    ErrorMessageWrongCode          ErrorEnum = "ERROR_MESSAGE_WRONG_CODE"
    ErrorInvalidVerifyToken        ErrorEnum = "ERROR_INVALID_VERIFY_TOKEN"
    ErrorChannelNotAllowedCountry  ErrorEnum = "ERROR_CHANNEL_NOT_ALLOWED_COUNTRY"
    ErrorMessageAttempt            ErrorEnum = "ERROR_MESSAGE_ATTEMPT"
    ErrorPhoneBlocked              ErrorEnum = "ERROR_PHONE_BLOCKED"
    ErrorBlocked                   ErrorEnum = "ERROR_BLOCKED"
    ErrorChallenge                 ErrorEnum = "ERROR_CHALLENGE"
    ErrorBadRequest                ErrorEnum = "ERROR_BAD_REQUEST"
    ErrorWrongBalance              ErrorEnum = "ERROR_WRONG_BALANCE"
    ErrorAccessDenied              ErrorEnum = "ERROR_ACCESS_DENIED"
    ErrorRequestLimitReached       ErrorEnum = "ERROR_REQUEST_LIMIT_REACHED"
    ErrorMessageNotFound           ErrorEnum = "ERROR_MESSAGE_NOT_FOUND"
)

#[derive(serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ErrorEnum {
    TechnicalWork,
    ErrorProjectHasNoChannels,
    ErrorProjectHasNoChannel,
    ErrorUserNotAuthorizeOnChannel,
    ErrorSessionExpired,
    ErrorMessageWrongCode,
    ErrorInvalidVerifyToken,
    ErrorChannelNotAllowedCountry,
    ErrorMessageAttempt,
    ErrorPhoneBlocked,
    ErrorBlocked,
    ErrorChallenge,
    ErrorBadRequest,
    ErrorWrongBalance,
    ErrorAccessDenied,
    ErrorRequestLimitReached,
    ErrorMessageNotFound,
}

impl From<ErrorEnum> for String {
    fn from(val: ErrorEnum) -> String {
        match val {
            ErrorEnum::TechnicalWork => "TECHNICAL_WORK",
            ErrorEnum::ErrorProjectHasNoChannels => "ERROR_PROJECT_HAS_NO_CHANNELS",
            ErrorEnum::ErrorProjectHasNoChannel => "ERROR_PROJECT_HAS_NO_CHANNEL",
            ErrorEnum::ErrorUserNotAuthorizeOnChannel => "ERROR_USER_NOT_AUTHORIZE_ON_CHANNEL",
            ErrorEnum::ErrorSessionExpired => "ERROR_SESSION_EXPIRED",
            ErrorEnum::ErrorMessageWrongCode => "ERROR_MESSAGE_WRONG_CODE",
            ErrorEnum::ErrorInvalidVerifyToken => "ERROR_INVALID_VERIFY_TOKEN",
            ErrorEnum::ErrorChannelNotAllowedCountry => "ERROR_CHANNEL_NOT_ALLOWED_COUNTRY",
            ErrorEnum::ErrorMessageAttempt => "ERROR_MESSAGE_ATTEMPT",
            ErrorEnum::ErrorPhoneBlocked => "ERROR_PHONE_BLOCKED",
            ErrorEnum::ErrorBlocked => "ERROR_BLOCKED",
            ErrorEnum::ErrorChallenge => "ERROR_CHALLENGE",
            ErrorEnum::ErrorBadRequest => "ERROR_BAD_REQUEST",
            ErrorEnum::ErrorWrongBalance => "ERROR_WRONG_BALANCE",
            ErrorEnum::ErrorAccessDenied => "ERROR_ACCESS_DENIED",
            ErrorEnum::ErrorRequestLimitReached => "ERROR_REQUEST_LIMIT_REACHED",
            ErrorEnum::ErrorMessageNotFound => "ERROR_MESSAGE_NOT_FOUND",
        }
        .into()
    }
}

impl AsRef<str> for ErrorEnum {
    fn as_ref(&self) -> &str {
        match self {
            ErrorEnum::TechnicalWork => "TECHNICAL_WORK",
            ErrorEnum::ErrorProjectHasNoChannels => "ERROR_PROJECT_HAS_NO_CHANNELS",
            ErrorEnum::ErrorProjectHasNoChannel => "ERROR_PROJECT_HAS_NO_CHANNEL",
            ErrorEnum::ErrorUserNotAuthorizeOnChannel => "ERROR_USER_NOT_AUTHORIZE_ON_CHANNEL",
            ErrorEnum::ErrorSessionExpired => "ERROR_SESSION_EXPIRED",
            ErrorEnum::ErrorMessageWrongCode => "ERROR_MESSAGE_WRONG_CODE",
            ErrorEnum::ErrorInvalidVerifyToken => "ERROR_INVALID_VERIFY_TOKEN",
            ErrorEnum::ErrorChannelNotAllowedCountry => "ERROR_CHANNEL_NOT_ALLOWED_COUNTRY",
            ErrorEnum::ErrorMessageAttempt => "ERROR_MESSAGE_ATTEMPT",
            ErrorEnum::ErrorPhoneBlocked => "ERROR_PHONE_BLOCKED",
            ErrorEnum::ErrorBlocked => "ERROR_BLOCKED",
            ErrorEnum::ErrorChallenge => "ERROR_CHALLENGE",
            ErrorEnum::ErrorBadRequest => "ERROR_BAD_REQUEST",
            ErrorEnum::ErrorWrongBalance => "ERROR_WRONG_BALANCE",
            ErrorEnum::ErrorAccessDenied => "ERROR_ACCESS_DENIED",
            ErrorEnum::ErrorRequestLimitReached => "ERROR_REQUEST_LIMIT_REACHED",
            ErrorEnum::ErrorMessageNotFound => "ERROR_MESSAGE_NOT_FOUND",
        }
    }
}