* Run the remaining E2E groups using GitHub Actions

* Remove Snowplow from CCI

* Remove waiting for databases from CCI

* Remove Cypress jobs from CCI

* Remove `fe-deps` from CCI

* Remove `tester` executor from CCI

* Remove all frontend-related from CCI

* Remove static viz bundle from CCI

* Remove E2E checksum from CCI

* Remove frontend checksum from CCI

* Trigger CI run #1

* Trigger CI run #2

* Trigger CI run #3

* Trigger CI run #4

* Trigger CI run #5

* ValidationError package created

* ValidationError imports updated

* add exceeded_limit column and set it to true when values of a list field exceed our defined limits

* move exceeded_limit to has_more_values in metabase_fieldvalues

* make fieldvalues search not do in-memory search if has_more_values=true

* resolve Noah's comments and make the comments clearer

* Offer transparent background in embedding

* Remove nighttime mode toggle for transparent embedded dashboard

* Refactor hasNightModeToggle

* Optimize checkerboard file size

* Add Percy to the main E2E workflow

* Ignore unit tests

* Delete Percy workflow

* Do not run Percy tests on Cypress changes only

* Check whether visual regression tests should run at all

* fix subscriptions and alerts

* review

* specs

* Updating Dashboard Action Menu, Moving bookmark action

* Fixing Tests

* Add `can-manage` property to `Database` types

* Only show enable/disable caching with DB access

* Rename `tooltip` which is not a tooltip anymore

* Remove redundant variable

* Move model cache section to OSS

* Don't handle "off" state as it won't be shown

* Tweak copy

* Join slack channels with slack-id

Fixes https://github.com/metabase/metabase/issues/23229

We upload images to a channel and then send messages to the desired
channel referencing those images from the channel we uploaded. But the
slack bot must be in the channel to upload images.

We handle this in `slack/upload-image!` where we watch the error message
and join the channel if we recognize that is our issue. This special
upload channel is set in the admin section when setting up, typed in by
a human.

Slack now requires us to use the internal id of the channel when
joining. IE we used to use "metabase_files" but now we need to use
something like "C87LQNL0Y23". But we do not have this information and we
don't want humans to have to look this up.

SOLUTION:
change our cache. We currently just get a list of channels and users
```
["#general" "@dan" ...]
```

Change this to
```
{:version 2,
 :channels [{:display-name "#random",
             :name "random",
             :id "CT2FNGZSRPL",
             :type "channel"}
            {:display-name "#general",
             :name "general",
             :id "C87LQNL0Y23",
             :type "channel"}
            {:display-name "@dan",
             :type "user",
             :name "dan",
             :id "UR65C4ZJVIW"}
            ...]}
```

Now we have slack internal ids present. When we attempt to join the
slack channel, look for this id and attempt to use that.

This has some knock-on effects. The UI still lists the channels in a
channel picker when sending pulses. The list sent over the wire still
mimics the previous shape (a flat list) and the choice is still the
human readable name.

In the future we should switch over to using the stable ids rather than
solely channel names. Channel names can be renamed.

I didn't go down this route because of the files channel. It is set at
setup before we have a channel list. We could do some kind of run time
migration but it is difficult because it would change the type of
`slack-files-channel` from string to :json to handle the more complex
type. Or perhaps we could make another setting to hold the json form and
set that when we can positively identify things.

In either case, these changes were not required yet to fix our slack
issue. We just upgrade the information we have about slack channels,
downgrade it when it hits the wire so the UI needs no changes, and use
the extra information in the one spot where we need it.

The cache is populated at startup and every four hours after that. So we
do not need to worry about the old cache shape. If the new code is
running, its the new cache.

* Send #channel and @user forms over wire

We store `{"channel": "#slack-pulses"}` in the pulse_channel.details
column so we should keep those types of values around.

We use the bare portion ("slack-pulses") rather than with the hash on it
so we seem to be mixing usernames and channels. But these sets are
distinct and you cannot create a channel with the same name as a
user. Also, channel names are lowercase while channel-ids are uppercase
so those are also non-overlapping sets.

* Put slack token so slack reports as configured

* Errant tap>

* Alignment and docstring fixes

* Remove slack-cache version information

remove the `:version 2` from the cache. We are always in charge of the
cache, and we compute it on startup so there's little risk of other data
shapes being present.

* fix tooltip overflow

* explicit default for preventOverflow

* check ci

* show field options in popover

* application-colors have new keys that may be added via the getter

Some colors previously had multiple usage contexts. For example, `accent1` was used both in charts and other parts of
the summarize UI. Now, those notions are being separated, so `accent1` remains a valid key, and `summarize` is a new
valid key. To make sure behaviour remains the same for existing whitelabel users who may have set these keys, when
such a key exists, it is 'split' by the getter.

For example, if the existing application-colors json contains `accent1`, the getter will add a new key `summarize`
with the same value as `accent1`, but only if `accent1` already exists, otherwise it does nothing. This is also true
for keys `brand`, which adds `accent0`, and `accent7`, which adds `filter`

* Make application colors getter make change only once

* Premium feature flag for test

Add Inline Date picker to bulk filter modal

* Stop caching /api/geojson/:key requests

* Remove extra require

This supports serialization of only Collections and Settings so far, but
it demonstrates the design of the new serialization system.

`metabase.models.serialization.base` defines the multimethods, which
are to be implemented by all the exported models eventually.
The actual serialization code that drives the larger process is in
`metabase_enterprise.serialization.v2.extract` and `.merge`, since
serialization is an enterprise feature.

The design calls for two matching phases on each side:
- Serialization is extract + store;
- Deserialization is ingest + load.

Extract and load deal with vanilla Clojure maps with a `serdes/meta` key
giving common details; they deliberately know nothing about files.

Store and ingest deal with the storage medium and the process of
listing and reading a stored export.

Laziness is retained: the `load` process ingests full details on demand,
so only the metadata of the importing database needs to fit in memory.

Since I forgot to add a condition to only test pro/enterprise version
only. 

* better filter validity check