Sublime MQL rules: recon

type.inbound
and (
  length(recipients.bcc) > 0
  or length(recipients.cc) > 0
  or any(recipients.to, strings.ilike(.display_name, "undisclosed?recipients"))
)
and (
  length(subject.base) <= 10
  or (
    (
      strings.ilike(subject.base, "*checking*", "*testing*")
      or subject.base == body.current_thread.text
    )
    and length(subject.base) <= 25
  )
)
and length(attachments) == 0
// and there are no links. Or all the links are to aka.ms or an extraction from a warning banner that match the senders domain
and (
  length(body.links) == 0
  or length(filter(body.links,
                   (
                     .display_text is null
                     and .display_url.url == sender.email.domain.root_domain
                   )
                   or .href_url.domain.domain == "aka.ms"
            )
  ) == length(body.links)
)
and (
  body.current_thread.text is null
  or length(body.current_thread.text) < 50
  or (
    length(body.current_thread.text) < 900
    // or body is most likely all warning banner ending with a generic greeting
    and regex.imatch(body.current_thread.text, '.*(hi|hello)')
  )
  // body length without disclaimer is shorter than 50 characters
  or (
    any(map(filter(ml.nlu_classifier(body.current_thread.text).entities,
                   .name == "disclaimer"
            ),
            .text
        ),
        (length(body.current_thread.text) - length(.)) < 50
    )
  )
  // matching nlu_classifier 'bec' to smaller messages less than 200
  or (
    any(ml.nlu_classifier(body.current_thread.text).intents,
        .name == "bec" and .confidence in ("high", "medium")
    )
    and length(body.current_thread.text) < 200
    and not regex.icontains(body.html.raw,
                            '(?:<div data-smartmail=|gmail_signature(?:_[^"]*)?)'
    ) // not condition to exclude smaller messages with a legitimate email signature
    and length(body.previous_threads) == 0 // excluding messages with simple responses to other threads
  )
)
and profile.by_sender().prevalence != "common"
and not profile.by_sender().solicited
and not profile.by_sender().any_messages_benign

// negate highly trusted sender domains unless they fail DMARC authentication
and (
  (
    sender.email.domain.root_domain in $high_trust_sender_root_domains
    and not headers.auth_summary.dmarc.pass
  )
  or sender.email.domain.root_domain not in $high_trust_sender_root_domains
)

type.inbound
and length(subject.base) <= 15
// detect email addresses in body text
and (
  regex.imatch(body.current_thread.text,
               '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
  )
)
// external freemail sender
and sender.email.domain.root_domain in $free_email_providers
// no attachments but allow one link
and length(attachments) == 0
and length(body.current_thread.links) == 1

type.inbound
and subject.base == ""
and (
  body.plain.raw is null
  or body.plain.raw == ""
  or regex.imatch(body.plain.raw, '^\s*$')
)
and (
  body.html.raw is null
  or body.html.raw == ""
  or regex.imatch(body.html.raw, '^\s*$')
)
and length(attachments) == 0
and profile.by_sender().prevalence != "common"

type.inbound
and profile.by_sender_email().prevalence == "new"
and subject.base == ""
and length(headers.reply_to) > 0
and sender.email.email not in map(headers.reply_to, .email.email)

type.inbound
and (
  body.plain.raw is null
  or body.plain.raw == ""
  or regex.imatch(body.plain.raw, '^\s*$')
)
and (
  body.html.raw is null
  or body.html.raw == ""
  or regex.imatch(body.html.raw, '^\s*$')
)
and length(subject.base) > 150
and (
  strings.icontains(subject.base, 'purchase a home')
  or regex.icontains(subject.base,
                     'the listing (?:on|at)',
                     '(?:interested in|regarding) (?:this|the) property',
                     '(?:will be|are) relocating'
  )
)

type.inbound
and any(headers.reply_to,
        .email.domain.root_domain in $free_email_providers
        and .email.domain.root_domain != sender.email.domain.root_domain
)
and all(recipients.to,
        .email.domain.root_domain != sender.email.domain.root_domain
)
and length(body.links) == 0
and length(attachments) == 0
and length(body.current_thread.text) < 600
and not (
  (subject.is_reply or subject.is_forward)
  and (length(headers.references) > 0 or headers.in_reply_to is not null)
)
and (
  (
    strings.ilike(body.current_thread.text,
                  '*hotel*',
                  '*your property*',
                  '*accommodation*',
                  '*guest services*',
                  '*reception*',
                  '*front desk*'
    )
    and strings.ilike(body.current_thread.text,
                      '*booking*',
                      '*to book*',
                      '*book a *',
                      '*reserv*',
                      '*room*',
                      '*suite*',
                      '*availability*',
                      '*check-in*',
                      '*available dates*',
                      '*family trip*',
                      '*deluxe accommodation*',
                      '*two children*',
                      '*hotel manager*'
    )
  )
  or strings.ilike(subject.base,
                   '*hotel*',
                   '*room reserv*',
                   '*room inquiry*',
                   '*room availability*',
                   '*suite*',
                   '*accommodation*'
  )
)

type.inbound
and (
  length(recipients.to) > 10
  and length(filter(recipients.to,
                    .email.domain.domain not in $org_domains
                    and .email.email not in $recipient_emails
                    and (
                      .email.domain.valid
                      or strings.icontains(.display_name, "undisclosed")
                    )
             )
  ) >= 10
)
and (
  length(subject.subject) <= 10 
  or subject.subject == body.current_thread.text
  or (subject.is_reply and length(body.previous_threads) == 0)
)
and (
  length(body.links) == 0
  or length(filter(body.links,
                   (
                     .display_text is null
                     and .display_url.url == sender.email.domain.root_domain
                   )
                   or .href_url.domain.domain == "aka.ms"
                   or network.whois(.display_url.domain).days_old < 30
            )
  ) == length(body.links)
)
and (
  length(attachments) == 0
  or (
    length(attachments) == 1
    and any(attachments,
            .file_type in ("pdf", "png", "jpg", "tif", "heif", "doc", "docx")
            and any(file.explode(.),
                    length(.scan.ocr.raw) < 20
                    or length(.scan.strings.strings) == 1
            )
    )
  )
)
and (
  body.current_thread.text is null
  or length(body.current_thread.text) < 50
  // body length without disclaimer is shorter than 50 characters
  or (
    any(map(filter(ml.nlu_classifier(body.current_thread.text).entities,
                   .name == "disclaimer"
            ),
            .text
        ),
        (length(body.current_thread.text) - length(.)) < 50
    )
  )
)
and profile.by_sender().prevalence != "common"
and not profile.by_sender().solicited
and not profile.by_sender().any_messages_benign

// negate highly trusted sender domains unless they fail DMARC authentication
and (
  (
    sender.email.domain.root_domain in $high_trust_sender_root_domains
    and not headers.auth_summary.dmarc.pass
  )
  or sender.email.domain.root_domain not in $high_trust_sender_root_domains
)

type.inbound
// detect generic greetings
and length(body.current_thread.text) <= 20
and length(subject.base) <= 15
// exclude messages with previous thread context (forwards/replies)
and length(body.previous_threads) == 0
and (
  any(ml.nlu_classifier(body.current_thread.text).entities, .name == "greeting")
  or strings.ilike(body.current_thread.text, "*hi*", "*hello*", "*hey*")
  or length(body.current_thread.text) <= 5
  or regex.match(body.current_thread.text, '\d+')
)
// external freemail sender
and sender.email.domain.root_domain in $free_email_providers
and (
  sender.email.domain.root_domain not in (
    recipients.to[0].email.domain.root_domain
  )
  or (
    (
      all(recipients.to, .email.domain.valid == false)
      and all(recipients.cc, .email.domain.valid == false)
    )
    or length(recipients.to) == 0
  )
)
and (
  length(recipients.cc) == 0
  or (
    length(recipients.cc) > 0
    and all(recipients.cc,
            .email.domain.root_domain != sender.email.domain.root_domain
    )
  )
)
and (
  length(recipients.bcc) == 0
  or (
    length(recipients.bcc) > 0
    and all(recipients.bcc,
            .email.domain.root_domain != sender.email.domain.root_domain
    )
  )
)
// no attachments or links
and length(attachments) == 0
and length(body.current_thread.links) == 0

// not where the sender and mailbox display_anames indicate this might be a personal email --> work email
// impersonation is covered by other core feed rules
and not (
  sum([length(recipients.to), length(recipients.bcc), length(recipients.cc)]) == 1
  // use coalesce to deal with either the sender.display_name or the mailbox element being null
  // if either are null, the function returns false, as it cannot be true if either is null
  and coalesce(strings.icontains(sender.display_name, mailbox.first_name),
               false
  )
  and coalesce(strings.icontains(sender.display_name, mailbox.last_name), false)
)
and (
  // auth failed (or absent) - ignore the profile
  coalesce(headers.auth_summary.dmarc.pass, false) == false
  or coalesce(headers.auth_summary.spf.pass, false) == false
  // auth passed - use the profile
  or (
    // no benign messages
    not profile.by_sender_email().any_messages_benign
    and (
      // not soliticed OR common
      not (
        profile.by_sender_email().solicited
        or profile.by_sender_email().prevalence == "common"
      )
      // or HAS been spam_malicious
      or profile.by_sender_email().any_messages_malicious_or_spam
    )
  )
)