diff --git a/Cargo.lock b/Cargo.lock
index c011278f528..7f57018224f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1382,6 +1382,7 @@ dependencies = [
 name = "icu_provider_macros"
 version = "0.5.0"
 dependencies = [
+ "icu_provider",
  "proc-macro2",
  "quote",
  "syn",
diff --git a/components/calendar/src/japanese.rs b/components/calendar/src/japanese.rs
index 89699e6da71..05fd69abdc5 100644
--- a/components/calendar/src/japanese.rs
+++ b/components/calendar/src/japanese.rs
@@ -27,19 +27,11 @@ pub struct JapaneseDateInner {
 
 impl Japanese {
     /// Creates a new [`Japanese`] from locale data and an options bag.
-    pub fn try_new<D: DataProvider<provider::JapaneseErasV1Marker> + ?Sized>(
+    pub fn try_new<D: ResourceProvider<provider::JapaneseErasV1Marker> + ?Sized>(
         data_provider: &D,
     ) -> Result<Self, DataError> {
         let eras = data_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::JAPANESE_ERAS_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: None,
-                    },
-                },
-            })?
+            .load_resource(&DataRequest::default())?
             .take_payload()?;
         Ok(Self { eras })
     }
diff --git a/components/calendar/src/provider.rs b/components/calendar/src/provider.rs
index cef2ec95d69..513263ed390 100644
--- a/components/calendar/src/provider.rs
+++ b/components/calendar/src/provider.rs
@@ -33,7 +33,7 @@ pub struct EraStartDate {
     pub day: u8,
 }
 
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(JapaneseErasV1Marker = "calendar/japanese@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/datetime/README.md b/components/datetime/README.md
index 2c4e8fee35e..143beb8a517 100644
--- a/components/datetime/README.md
+++ b/components/datetime/README.md
@@ -5,7 +5,7 @@
 This API provides necessary functionality for formatting date and time to user readable textual representation.
 
 [`DateTimeFormat`] is the main structure of the component. It accepts a set of arguments which
-allow it to collect necessary data from the [`DataProvider`], and once instantiated, can be
+allow it to collect necessary data from the [data provider], and once instantiated, can be
 used to quickly format any date and time provided.
 
 ## Examples
@@ -64,7 +64,7 @@ we expect to add more ways to customize the output, like skeletons, and componen
 to develop core date and time APIs that will work as an input for this component. [`DateTime`] additionally
 has support for non-Gregorian calendars, which this module will eventually be able to format.
 
-[`DataProvider`]: icu_provider::DataProvider
+[data provider]: icu_provider
 [`ICU4X`]: ../icu/index.html
 [`Length`]: options::length
 [`DateTime`]: icu_calendar::DateTime
diff --git a/components/datetime/src/datetime.rs b/components/datetime/src/datetime.rs
index a4be0f02e28..0dd2ea5002e 100644
--- a/components/datetime/src/datetime.rs
+++ b/components/datetime/src/datetime.rs
@@ -13,13 +13,13 @@ use crate::{
 use alloc::string::String;
 use core::marker::PhantomData;
 use icu_locid::Locale;
-use icu_plurals::provider::PluralRulesV1Marker;
+use icu_plurals::provider::OrdinalV1Marker;
 use icu_provider::prelude::*;
 
 use crate::{date::DateTimeInput, CldrCalendar, DateTimeFormatError, FormattedDateTime};
 
 /// [`DateTimeFormat`] is the main structure of the [`icu_datetime`] component.
-/// When constructed, it uses data from the [`DataProvider`], selected [`Locale`] and provided options to
+/// When constructed, it uses data from the [data provider], selected [`Locale`] and provided options to
 /// collect all data necessary to format any dates into that locale.
 ///
 /// For that reason, one should think of the process of formatting a date in two steps - first, a computational
@@ -56,12 +56,13 @@ use crate::{date::DateTimeInput, CldrCalendar, DateTimeFormatError, FormattedDat
 /// let value = dtf.format_to_string(&datetime);
 /// ```
 ///
-/// This model replicates that of `ICU` and `ECMA402`. In the future this will become even more pronounced
-/// when we introduce asynchronous [`DataProvider`] and corresponding asynchronous constructor.
+/// This model replicates that of `ICU` and `ECMA402`.
+///
+/// [data provider]: icu_provider
 pub struct DateTimeFormat<C>(pub(super) raw::DateTimeFormat, PhantomData<C>);
 
 impl<C: CldrCalendar> DateTimeFormat<C> {
-    /// Constructor that takes a selected [`Locale`], reference to a [`DataProvider`] and
+    /// Constructor that takes a selected [`Locale`], reference to a [data provider] and
     /// a list of options, then collects all data necessary to format date and time values into the given locale.
     ///
     /// # Examples
@@ -83,6 +84,8 @@ impl<C: CldrCalendar> DateTimeFormat<C> {
     ///
     /// assert_eq!(dtf.is_ok(), true);
     /// ```
+    ///
+    /// [data provider]: icu_provider
     #[inline]
     pub fn try_new<T: Into<Locale>, D>(
         locale: T,
@@ -90,10 +93,10 @@ impl<C: CldrCalendar> DateTimeFormat<C> {
         options: &DateTimeFormatOptions,
     ) -> Result<Self, DateTimeFormatError>
     where
-        D: DataProvider<DateSymbolsV1Marker>
-            + DataProvider<DatePatternsV1Marker>
-            + DataProvider<DateSkeletonPatternsV1Marker>
-            + DataProvider<PluralRulesV1Marker>,
+        D: ResourceProvider<DateSymbolsV1Marker>
+            + ResourceProvider<DatePatternsV1Marker>
+            + ResourceProvider<DateSkeletonPatternsV1Marker>
+            + ResourceProvider<OrdinalV1Marker>,
     {
         Ok(Self(
             raw::DateTimeFormat::try_new(locale, data_provider, options, C::IDENTIFIER)?,
diff --git a/components/datetime/src/error.rs b/components/datetime/src/error.rs
index 76946e7b5a4..5f62299a7a2 100644
--- a/components/datetime/src/error.rs
+++ b/components/datetime/src/error.rs
@@ -20,7 +20,7 @@ pub enum DateTimeFormatError {
     /// An error originating from the [`Write`](std::fmt::Write) trait.
     #[displaydoc("{0}")]
     Format(core::fmt::Error),
-    /// An error originating inside of the [`DataProvider`](icu_provider::DataProvider).
+    /// An error originating inside of the [data provider](icu_provider).
     #[displaydoc("{0}")]
     DataProvider(DataError),
     /// An error originating from a missing field in datetime input.
diff --git a/components/datetime/src/format/datetime.rs b/components/datetime/src/format/datetime.rs
index 9c12be54cb2..729af765706 100644
--- a/components/datetime/src/format/datetime.rs
+++ b/components/datetime/src/format/datetime.rs
@@ -359,14 +359,12 @@ mod tests {
 
         let provider = icu_testdata::get_provider();
         let data: DataPayload<DateSymbolsV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::DATE_SYMBOLS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some("en".parse().unwrap()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some("en".parse().unwrap()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
diff --git a/components/datetime/src/lib.rs b/components/datetime/src/lib.rs
index 9d2b6785dc6..395acca9c5e 100644
--- a/components/datetime/src/lib.rs
+++ b/components/datetime/src/lib.rs
@@ -9,7 +9,7 @@
 //! This API provides necessary functionality for formatting date and time to user readable textual representation.
 //!
 //! [`DateTimeFormat`] is the main structure of the component. It accepts a set of arguments which
-//! allow it to collect necessary data from the [`DataProvider`], and once instantiated, can be
+//! allow it to collect necessary data from the [data provider], and once instantiated, can be
 //! used to quickly format any date and time provided.
 //!
 //! # Examples
@@ -70,7 +70,7 @@
 //! to develop core date and time APIs that will work as an input for this component. [`DateTime`] additionally
 //! has support for non-Gregorian calendars, which this module will eventually be able to format.
 //!
-//! [`DataProvider`]: icu_provider::DataProvider
+//! [data provider]: icu_provider
 //! [`ICU4X`]: ../icu/index.html
 //! [`Length`]: options::length
 //! [`DateTime`]: icu_calendar::DateTime
diff --git a/components/datetime/src/provider/calendar/mod.rs b/components/datetime/src/provider/calendar/mod.rs
index 94e1590bbfe..9b2de0d7481 100644
--- a/components/datetime/src/provider/calendar/mod.rs
+++ b/components/datetime/src/provider/calendar/mod.rs
@@ -8,14 +8,12 @@ mod skeletons;
 mod symbols;
 
 use crate::pattern;
-use icu_provider::{
-    yoke::{self, *},
-    DataMarker,
-};
+use icu_provider::prelude::*;
+use icu_provider::yoke;
 pub use skeletons::*;
 pub use symbols::*;
 
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(DatePatternsV1Marker = "datetime/lengths@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/datetime/src/provider/calendar/skeletons.rs b/components/datetime/src/provider/calendar/skeletons.rs
index 03cd3ab05d6..6edc2070391 100644
--- a/components/datetime/src/provider/calendar/skeletons.rs
+++ b/components/datetime/src/provider/calendar/skeletons.rs
@@ -9,10 +9,10 @@ use crate::{
     skeleton::{reference::Skeleton, SkeletonError},
 };
 use core::convert::TryFrom;
-use icu_provider::yoke::{self, *};
+use icu_provider::yoke;
 use litemap::LiteMap;
 
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(DateSkeletonPatternsV1Marker = "datetime/skeletons@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/datetime/src/provider/calendar/symbols.rs b/components/datetime/src/provider/calendar/symbols.rs
index 4e88c5ad6dd..4b686aa5a8c 100644
--- a/components/datetime/src/provider/calendar/symbols.rs
+++ b/components/datetime/src/provider/calendar/symbols.rs
@@ -8,7 +8,7 @@ use alloc::borrow::Cow;
 use icu_provider::yoke::{self, *};
 use zerovec::map::ZeroMap;
 
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(DateSymbolsV1Marker = "datetime/symbols@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/datetime/src/provider/date_time.rs b/components/datetime/src/provider/date_time.rs
index cba5085fe5b..196e75e3368 100644
--- a/components/datetime/src/provider/date_time.rs
+++ b/components/datetime/src/provider/date_time.rs
@@ -81,7 +81,7 @@ impl<D> Clone for PatternSelector<'_, D> {
 
 impl<D> PatternSelector<'_, D>
 where
-    D: DataProvider<DatePatternsV1Marker> + DataProvider<DateSkeletonPatternsV1Marker>,
+    D: ResourceProvider<DatePatternsV1Marker> + ResourceProvider<DateSkeletonPatternsV1Marker>,
 {
     pub(crate) fn for_options<'a>(
         data_provider: &'a D,
@@ -208,14 +208,12 @@ where
     fn patterns_data_payload(self) -> Result<DataPayload<DatePatternsV1Marker>> {
         let data = self
             .data_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::DATE_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some(self.calendar.into()),
-                        langid: Some(self.locale.clone().into()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some(self.calendar.into()),
+                    langid: Some(self.locale.clone().into()),
                 },
+                metadata: Default::default(),
             })?
             .take_payload()?;
         Ok(data)
@@ -224,14 +222,12 @@ where
     fn skeleton_data_payload(self) -> Result<DataPayload<DateSkeletonPatternsV1Marker>> {
         let data = self
             .data_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::DATE_SKELETON_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some(self.calendar.into()),
-                        langid: Some(self.locale.clone().into()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some(self.calendar.into()),
+                    langid: Some(self.locale.clone().into()),
                 },
+                metadata: Default::default(),
             })?
             .take_payload()?;
         Ok(data)
diff --git a/components/datetime/src/provider/time_zones.rs b/components/datetime/src/provider/time_zones.rs
index ff0ba089e0a..8628aea7383 100644
--- a/components/datetime/src/provider/time_zones.rs
+++ b/components/datetime/src/provider/time_zones.rs
@@ -3,7 +3,7 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 use alloc::borrow::Cow;
-use icu_provider::yoke::{self, *};
+use icu_provider::yoke;
 use litemap::LiteMap;
 use tinystr::TinyStr8;
 
@@ -84,7 +84,7 @@ macro_rules! map_access_with_overrides {
 
 /// An ICU4X mapping to the CLDR timeZoneNames format strings.
 /// See CLDR-JSON timeZoneNames.json for more context.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(TimeZoneFormatsV1Marker = "time_zone/formats@1")]
 #[derive(PartialEq, Debug, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -109,7 +109,7 @@ pub struct TimeZoneFormatsV1<'data> {
 
 /// An ICU4X mapping to the CLDR timeZoneNames exemplar cities.
 /// See CLDR-JSON timeZoneNames.json for more context.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(ExemplarCitiesV1Marker = "time_zone/exemplar_cities@1")]
 #[derive(PartialEq, Debug, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -121,7 +121,7 @@ map_access!(ExemplarCitiesV1<'data>[str] => Cow<'data, str>: 'data);
 
 /// An ICU4X mapping to the long-form generic metazone names.
 /// See CLDR-JSON timeZoneNames.json for more context.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(MetaZoneGenericNamesLongV1Marker = "time_zone/generic_long@1")]
 #[derive(PartialEq, Debug, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -138,7 +138,7 @@ map_access_with_overrides!(MetaZoneGenericNamesLongV1<'data>[str] => Cow<'data,
 
 /// An ICU4X mapping to the short-form generic metazone names.
 /// See CLDR-JSON timeZoneNames.json for more context.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(MetaZoneGenericNamesShortV1Marker = "time_zone/generic_short@1")]
 #[derive(PartialEq, Debug, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -156,7 +156,7 @@ map_access_with_overrides!(MetaZoneGenericNamesShortV1<'data>[str] => Cow<'data,
 /// An ICU4X mapping to the long-form specific metazone names.
 /// Specific names include time variants such as "daylight."
 /// See CLDR-JSON timeZoneNames.json for more context.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(MetaZoneSpecificNamesLongV1Marker = "time_zone/specific_long@1")]
 #[derive(PartialEq, Debug, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -174,7 +174,7 @@ map_access_with_overrides!(MetaZoneSpecificNamesLongV1<'data>[str] => MetaZoneSp
 /// An ICU4X mapping to the short-form specific metazone names.
 /// Specific names include time variants such as "daylight."
 /// See CLDR-JSON timeZoneNames.json for more context.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(MetaZoneSpecificNamesShortV1Marker = "time_zone/specific_short@1")]
 #[derive(PartialEq, Debug, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/datetime/src/raw/datetime.rs b/components/datetime/src/raw/datetime.rs
index 1f391965055..08ea6ebf45b 100644
--- a/components/datetime/src/raw/datetime.rs
+++ b/components/datetime/src/raw/datetime.rs
@@ -14,7 +14,7 @@ use crate::{
 };
 use alloc::string::String;
 use icu_locid::Locale;
-use icu_plurals::{provider::PluralRulesV1Marker, PluralRuleType, PluralRules};
+use icu_plurals::{provider::OrdinalV1Marker, PluralRules};
 use icu_provider::prelude::*;
 
 use crate::{
@@ -44,10 +44,10 @@ impl DateTimeFormat {
         calendar: &'static str,
     ) -> Result<Self, DateTimeFormatError>
     where
-        D: DataProvider<DateSymbolsV1Marker>
-            + DataProvider<DatePatternsV1Marker>
-            + DataProvider<DateSkeletonPatternsV1Marker>
-            + DataProvider<PluralRulesV1Marker>,
+        D: ResourceProvider<DateSymbolsV1Marker>
+            + ResourceProvider<DatePatternsV1Marker>
+            + ResourceProvider<DateSkeletonPatternsV1Marker>
+            + ResourceProvider<OrdinalV1Marker>,
     {
         let locale = locale.into();
 
@@ -64,11 +64,7 @@ impl DateTimeFormat {
         let langid: icu_locid::LanguageIdentifier = locale.clone().into();
 
         let ordinal_rules = if let PatternPlurals::MultipleVariants(_) = &patterns.get().0 {
-            Some(PluralRules::try_new(
-                locale.clone(),
-                data_provider,
-                PluralRuleType::Ordinal,
-            )?)
+            Some(PluralRules::try_new_ordinal(locale.clone(), data_provider)?)
         } else {
             None
         };
@@ -76,14 +72,12 @@ impl DateTimeFormat {
         let symbols_data = if requires_data {
             Some(
                 data_provider
-                    .load_payload(&DataRequest {
-                        resource_path: ResourcePath {
-                            key: provider::key::DATE_SYMBOLS_V1,
-                            options: ResourceOptions {
-                                variant: Some(calendar.into()),
-                                langid: Some(langid),
-                            },
+                    .load_resource(&DataRequest {
+                        options: ResourceOptions {
+                            variant: Some(calendar.into()),
+                            langid: Some(langid),
                         },
+                        metadata: Default::default(),
                     })?
                     .take_payload()?,
             )
diff --git a/components/datetime/src/raw/zoned_datetime.rs b/components/datetime/src/raw/zoned_datetime.rs
index f4630683775..055038f2976 100644
--- a/components/datetime/src/raw/zoned_datetime.rs
+++ b/components/datetime/src/raw/zoned_datetime.rs
@@ -4,8 +4,8 @@
 
 use alloc::string::String;
 use icu_locid::{LanguageIdentifier, Locale};
-use icu_plurals::{provider::PluralRulesV1Marker, PluralRuleType, PluralRules};
-use icu_provider::{DataProvider, DataRequest, ResourceOptions, ResourcePath};
+use icu_plurals::{provider::OrdinalV1Marker, PluralRules};
+use icu_provider::prelude::*;
 
 use crate::{
     date::ZonedDateTimeInput,
@@ -48,17 +48,17 @@ impl ZonedDateTimeFormat {
     ) -> Result<Self, DateTimeFormatError>
     where
         L: Into<Locale>,
-        DP: DataProvider<DateSymbolsV1Marker>
-            + DataProvider<DatePatternsV1Marker>
-            + DataProvider<DateSkeletonPatternsV1Marker>,
-        ZP: DataProvider<provider::time_zones::TimeZoneFormatsV1Marker>
-            + DataProvider<provider::time_zones::ExemplarCitiesV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
+        DP: ResourceProvider<DateSymbolsV1Marker>
+            + ResourceProvider<DatePatternsV1Marker>
+            + ResourceProvider<DateSkeletonPatternsV1Marker>,
+        ZP: ResourceProvider<provider::time_zones::TimeZoneFormatsV1Marker>
+            + ResourceProvider<provider::time_zones::ExemplarCitiesV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
             + ?Sized,
-        PP: DataProvider<PluralRulesV1Marker>,
+        PP: ResourceProvider<OrdinalV1Marker>,
     {
         let locale = locale.into();
         let langid: LanguageIdentifier = locale.clone().into();
@@ -74,10 +74,9 @@ impl ZonedDateTimeFormat {
             .map_err(|field| DateTimeFormatError::UnsupportedField(field.symbol))?;
 
         let ordinal_rules = if let PatternPlurals::MultipleVariants(_) = &patterns.get().0 {
-            Some(PluralRules::try_new(
+            Some(PluralRules::try_new_ordinal(
                 locale.clone(),
                 plural_provider,
-                PluralRuleType::Ordinal,
             )?)
         } else {
             None
@@ -86,14 +85,12 @@ impl ZonedDateTimeFormat {
         let symbols_data = if requires_data {
             Some(
                 date_provider
-                    .load_payload(&DataRequest {
-                        resource_path: ResourcePath {
-                            key: provider::key::DATE_SYMBOLS_V1,
-                            options: ResourceOptions {
-                                variant: Some(calendar.into()),
-                                langid: Some(langid),
-                            },
+                    .load_resource(&DataRequest {
+                        options: ResourceOptions {
+                            variant: Some(calendar.into()),
+                            langid: Some(langid),
                         },
+                        metadata: Default::default(),
                     })?
                     .take_payload()?,
             )
diff --git a/components/datetime/src/skeleton/mod.rs b/components/datetime/src/skeleton/mod.rs
index 79c562580e8..47725ce6c67 100644
--- a/components/datetime/src/skeleton/mod.rs
+++ b/components/datetime/src/skeleton/mod.rs
@@ -23,10 +23,7 @@ mod test {
     use crate::{
         fields::{Day, Field, FieldLength, Month, Weekday},
         options::components,
-        provider::{
-            calendar::DatePatternsV1Marker, calendar::DateSkeletonPatternsV1Marker,
-            key::DATE_PATTERNS_V1, key::DATE_SKELETON_PATTERNS_V1,
-        },
+        provider::{calendar::DatePatternsV1Marker, calendar::DateSkeletonPatternsV1Marker},
     };
     use core::convert::TryFrom;
 
@@ -42,27 +39,23 @@ mod test {
         let provider = icu_testdata::get_provider();
         let langid = langid!("en");
         let patterns = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .expect("Failed to load payload")
             .take_payload()
             .expect("Failed to retrieve payload");
         let skeletons = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_SKELETON_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid),
                 },
+                metadata: Default::default(),
             })
             .expect("Failed to load payload")
             .take_payload()
diff --git a/components/datetime/src/time_zone.rs b/components/datetime/src/time_zone.rs
index f1f6680bc3b..8bd9b102431 100644
--- a/components/datetime/src/time_zone.rs
+++ b/components/datetime/src/time_zone.rs
@@ -24,26 +24,23 @@ use icu_provider::prelude::*;
 /// Loads a resource into its destination if the destination has not already been filled.
 fn load_resource<D, L, P>(
     locale: &L,
-    resource_key: ResourceKey,
     destination: &mut Option<DataPayload<D>>,
     provider: &P,
 ) -> Result<(), DateTimeFormatError>
 where
-    D: DataMarker,
+    D: ResourceMarker,
     L: Clone + Into<LanguageIdentifier>,
-    P: DataProvider<D> + ?Sized,
+    P: ResourceProvider<D> + ?Sized,
 {
     if destination.is_none() {
         *destination = Some(
             provider
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key: resource_key,
-                        options: ResourceOptions {
-                            variant: None,
-                            langid: Some(locale.clone().into()),
-                        },
+                .load_resource(&DataRequest {
+                    options: ResourceOptions {
+                        langid: Some(locale.clone().into()),
+                        variant: None,
                     },
+                    metadata: Default::default(),
                 })?
                 .take_payload()?,
         );
@@ -51,7 +48,7 @@ where
     Ok(())
 }
 
-/// [`TimeZoneFormat`] uses data from the [`DataProvider`], the selected [`Locale`], and the provided
+/// [`TimeZoneFormat`] uses data from the [data provider], the selected [`Locale`], and the provided
 /// [`TimeZoneFormatConfig`] to collect all data necessary to format time zones into that locale.
 ///
 /// The various time-zone configs specified in UTS-35 require different sets of data for
@@ -87,6 +84,8 @@ where
 ///
 /// let value = tzf.format_to_string(&time_zone);
 /// ```
+///
+/// [data provider]: icu_provider
 pub struct TimeZoneFormat {
     // The kind of time zone format.
     pub(super) kind: TimeZoneFormatKind,
@@ -118,25 +117,20 @@ impl TimeZoneFormat {
     ) -> Result<Self, DateTimeFormatError>
     where
         L: Into<Locale>,
-        ZP: DataProvider<provider::time_zones::TimeZoneFormatsV1Marker>
-            + DataProvider<provider::time_zones::ExemplarCitiesV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
+        ZP: ResourceProvider<provider::time_zones::TimeZoneFormatsV1Marker>
+            + ResourceProvider<provider::time_zones::ExemplarCitiesV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
             + ?Sized,
     {
         let locale = locale.into();
 
         let zone_formats: DataPayload<TimeZoneFormatsV1Marker> = zone_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::TIMEZONE_FORMATS_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(locale.clone().into()),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: locale.clone().into(),
+                metadata: Default::default(),
             })?
             .take_payload()?;
 
@@ -173,18 +167,8 @@ impl TimeZoneFormat {
         for (length, symbol) in zone_symbols {
             match symbol {
                 TimeZone::LowerZ => match length {
-                    1..=3 => load_resource(
-                        &locale,
-                        provider::key::TIMEZONE_SPECIFIC_NAMES_SHORT_V1,
-                        &mut mz_specific_short,
-                        zone_provider,
-                    )?,
-                    4 => load_resource(
-                        &locale,
-                        provider::key::TIMEZONE_SPECIFIC_NAMES_LONG_V1,
-                        &mut mz_specific_long,
-                        zone_provider,
-                    )?,
+                    1..=3 => load_resource(&locale, &mut mz_specific_short, zone_provider)?,
+                    4 => load_resource(&locale, &mut mz_specific_long, zone_provider)?,
                     _ => {
                         return Err(DateTimeFormatError::Pattern(
                             PatternError::FieldLengthInvalid(FieldSymbol::TimeZone(symbol)),
@@ -193,32 +177,12 @@ impl TimeZoneFormat {
                 },
                 TimeZone::LowerV => match length {
                     1 => {
-                        load_resource(
-                            &locale,
-                            provider::key::TIMEZONE_GENERIC_NAMES_SHORT_V1,
-                            &mut mz_generic_short,
-                            zone_provider,
-                        )?;
-                        load_resource(
-                            &locale,
-                            provider::key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                            &mut exemplar_cities,
-                            zone_provider,
-                        )?;
+                        load_resource(&locale, &mut mz_generic_short, zone_provider)?;
+                        load_resource(&locale, &mut exemplar_cities, zone_provider)?;
                     }
                     4 => {
-                        load_resource(
-                            &locale,
-                            provider::key::TIMEZONE_GENERIC_NAMES_LONG_V1,
-                            &mut mz_generic_long,
-                            zone_provider,
-                        )?;
-                        load_resource(
-                            &locale,
-                            provider::key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                            &mut exemplar_cities,
-                            zone_provider,
-                        )?;
+                        load_resource(&locale, &mut mz_generic_long, zone_provider)?;
+                        load_resource(&locale, &mut exemplar_cities, zone_provider)?;
                     }
                     _ => {
                         return Err(DateTimeFormatError::Pattern(
@@ -229,12 +193,7 @@ impl TimeZoneFormat {
                 TimeZone::UpperV => match length {
                     1 => (), // BCP-47 identifier, no CLDR-data necessary.
                     2 => (), // IANA time-zone ID, no CLDR data necessary.
-                    3 | 4 => load_resource(
-                        &locale,
-                        provider::key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                        &mut exemplar_cities,
-                        zone_provider,
-                    )?,
+                    3 | 4 => load_resource(&locale, &mut exemplar_cities, zone_provider)?,
                     _ => {
                         return Err(DateTimeFormatError::Pattern(
                             PatternError::FieldLengthInvalid(FieldSymbol::TimeZone(symbol)),
@@ -283,25 +242,20 @@ impl TimeZoneFormat {
     ) -> Result<Self, DateTimeFormatError>
     where
         L: Into<Locale>,
-        ZP: DataProvider<provider::time_zones::TimeZoneFormatsV1Marker>
-            + DataProvider<provider::time_zones::ExemplarCitiesV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
+        ZP: ResourceProvider<provider::time_zones::TimeZoneFormatsV1Marker>
+            + ResourceProvider<provider::time_zones::ExemplarCitiesV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
             + ?Sized,
     {
         let locale = locale.into();
 
         let zone_formats: DataPayload<TimeZoneFormatsV1Marker> = zone_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::TIMEZONE_FORMATS_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(locale.clone().into()),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: locale.clone().into(),
+                metadata: Default::default(),
             })?
             .take_payload()?;
 
@@ -322,56 +276,21 @@ impl TimeZoneFormat {
 
         match config {
             TimeZoneFormatConfig::GenericNonLocationLong => {
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_GENERIC_NAMES_LONG_V1,
-                    &mut mz_generic_long,
-                    zone_provider,
-                )?;
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                    &mut exemplar_cities,
-                    zone_provider,
-                )?;
+                load_resource(&locale, &mut mz_generic_long, zone_provider)?;
+                load_resource(&locale, &mut exemplar_cities, zone_provider)?;
             }
             TimeZoneFormatConfig::GenericNonLocationShort => {
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_GENERIC_NAMES_SHORT_V1,
-                    &mut mz_generic_short,
-                    zone_provider,
-                )?;
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                    &mut exemplar_cities,
-                    zone_provider,
-                )?;
+                load_resource(&locale, &mut mz_generic_short, zone_provider)?;
+                load_resource(&locale, &mut exemplar_cities, zone_provider)?;
             }
             TimeZoneFormatConfig::GenericLocation => {
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                    &mut exemplar_cities,
-                    zone_provider,
-                )?;
+                load_resource(&locale, &mut exemplar_cities, zone_provider)?;
             }
             TimeZoneFormatConfig::SpecificNonLocationLong => {
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_SPECIFIC_NAMES_LONG_V1,
-                    &mut mz_specific_long,
-                    zone_provider,
-                )?;
+                load_resource(&locale, &mut mz_specific_long, zone_provider)?;
             }
             TimeZoneFormatConfig::SpecificNonLocationShort => {
-                load_resource(
-                    &locale,
-                    provider::key::TIMEZONE_SPECIFIC_NAMES_SHORT_V1,
-                    &mut mz_specific_short,
-                    zone_provider,
-                )?;
+                load_resource(&locale, &mut mz_specific_short, zone_provider)?;
             }
             TimeZoneFormatConfig::LocalizedGMT | TimeZoneFormatConfig::Iso8601(..) => (),
         }
diff --git a/components/datetime/src/zoned_datetime.rs b/components/datetime/src/zoned_datetime.rs
index 234f293ac44..44e198102a7 100644
--- a/components/datetime/src/zoned_datetime.rs
+++ b/components/datetime/src/zoned_datetime.rs
@@ -5,8 +5,8 @@
 use alloc::string::String;
 use core::marker::PhantomData;
 use icu_locid::Locale;
-use icu_plurals::provider::PluralRulesV1Marker;
-use icu_provider::DataProvider;
+use icu_plurals::provider::OrdinalV1Marker;
+use icu_provider::prelude::*;
 
 use crate::{
     date::ZonedDateTimeInput,
@@ -21,7 +21,7 @@ use crate::{
 
 /// The composition of [`DateTimeFormat`](crate::DateTimeFormat) and [`TimeZoneFormat`](crate::TimeZoneFormat).
 ///
-/// [`ZonedDateTimeFormat`] uses data from the [`DataProvider`]s, the selected [`Locale`], and the
+/// [`ZonedDateTimeFormat`] uses data from the [data provider]s, the selected [`Locale`], and the
 /// provided pattern to collect all data necessary to format a datetime with time zones into that locale.
 ///
 /// The various pattern symbols specified in UTS-35 require different sets of data for formatting.
@@ -66,8 +66,8 @@ use crate::{
 pub struct ZonedDateTimeFormat<C>(raw::ZonedDateTimeFormat, PhantomData<C>);
 
 impl<C: CldrCalendar> ZonedDateTimeFormat<C> {
-    /// Constructor that takes a selected [`Locale`], a reference to a [`DataProvider`] for
-    /// dates, a [`DataProvider`] for time zones, and a list of [`DateTimeFormatOptions`].
+    /// Constructor that takes a selected [`Locale`], a reference to a [data provider] for
+    /// dates, a [data provider] for time zones, and a list of [`DateTimeFormatOptions`].
     /// It collects all data necessary to format zoned datetime values into the given locale.
     ///
     /// # Examples
@@ -92,6 +92,8 @@ impl<C: CldrCalendar> ZonedDateTimeFormat<C> {
     ///
     /// assert_eq!(zdtf.is_ok(), true);
     /// ```
+    ///
+    /// [data provider]: icu_provider
     #[inline]
     pub fn try_new<L, DP, ZP, PP>(
         locale: L,
@@ -102,17 +104,17 @@ impl<C: CldrCalendar> ZonedDateTimeFormat<C> {
     ) -> Result<Self, DateTimeFormatError>
     where
         L: Into<Locale>,
-        DP: DataProvider<DateSymbolsV1Marker>
-            + DataProvider<DatePatternsV1Marker>
-            + DataProvider<DateSkeletonPatternsV1Marker>,
-        ZP: DataProvider<provider::time_zones::TimeZoneFormatsV1Marker>
-            + DataProvider<provider::time_zones::ExemplarCitiesV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
-            + DataProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
+        DP: ResourceProvider<DateSymbolsV1Marker>
+            + ResourceProvider<DatePatternsV1Marker>
+            + ResourceProvider<DateSkeletonPatternsV1Marker>,
+        ZP: ResourceProvider<provider::time_zones::TimeZoneFormatsV1Marker>
+            + ResourceProvider<provider::time_zones::ExemplarCitiesV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneGenericNamesShortV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesLongV1Marker>
+            + ResourceProvider<provider::time_zones::MetaZoneSpecificNamesShortV1Marker>
             + ?Sized,
-        PP: DataProvider<PluralRulesV1Marker>,
+        PP: ResourceProvider<OrdinalV1Marker>,
     {
         Ok(Self(
             raw::ZonedDateTimeFormat::try_new(
diff --git a/components/datetime/tests/datetime.rs b/components/datetime/tests/datetime.rs
index 9b57ea85519..ce1d7039806 100644
--- a/components/datetime/tests/datetime.rs
+++ b/components/datetime/tests/datetime.rs
@@ -19,7 +19,7 @@ use icu_datetime::{
     CldrCalendar, DateTimeFormat, DateTimeFormatOptions, ZonedDateTimeFormat,
 };
 use icu_locid::{LanguageIdentifier, Locale};
-use icu_plurals::provider::PluralRulesV1Marker;
+use icu_plurals::provider::OrdinalV1Marker;
 use icu_provider::fork::by_key::MultiForkByKeyProvider;
 use icu_provider::prelude::*;
 use icu_provider::struct_provider::AnyPayloadProvider;
@@ -98,10 +98,10 @@ fn assert_fixture_element<A, D>(
 ) where
     A: AsCalendar,
     A::Calendar: CldrCalendar,
-    D: DataProvider<DateSymbolsV1Marker>
-        + DataProvider<DatePatternsV1Marker>
-        + DataProvider<DateSkeletonPatternsV1Marker>
-        + DataProvider<PluralRulesV1Marker>,
+    D: ResourceProvider<DateSymbolsV1Marker>
+        + ResourceProvider<DatePatternsV1Marker>
+        + ResourceProvider<DateSkeletonPatternsV1Marker>
+        + ResourceProvider<OrdinalV1Marker>,
 {
     let locale: Locale = locale.parse().unwrap();
     let dtf = DateTimeFormat::<A::Calendar>::try_new(locale, provider, options).unwrap();
@@ -177,14 +177,12 @@ fn test_dayperiod_patterns() {
     for test in get_dayperiod_tests("dayperiods").unwrap().0 {
         let langid: LanguageIdentifier = test.locale.parse().unwrap();
         let mut patterns_data: DataPayload<DatePatternsV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -193,27 +191,23 @@ fn test_dayperiod_patterns() {
             data.length_combinations.long = "{0}".parse().unwrap();
         });
         let symbols_data: DataPayload<DateSymbolsV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_SYMBOLS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
             .unwrap();
         let skeleton_data: DataPayload<DateSkeletonPatternsV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_SKELETON_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -328,40 +322,34 @@ fn test_time_zone_patterns() {
         datetime.time_zone.time_variant = config.time_variant.take();
 
         let mut patterns_data: DataPayload<DatePatternsV1Marker> = date_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
             .unwrap();
         let skeleton_data: DataPayload<DateSkeletonPatternsV1Marker> = date_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_SKELETON_PATTERNS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
             .unwrap();
         let symbols_data: DataPayload<DateSymbolsV1Marker> = date_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: DATE_SYMBOLS_V1,
-                    options: ResourceOptions {
-                        variant: Some("gregory".into()),
-                        langid: Some(langid.clone()),
-                    },
+            .load_resource(&DataRequest {
+                options: ResourceOptions {
+                    variant: Some("gregory".into()),
+                    langid: Some(langid.clone()),
                 },
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
diff --git a/components/decimal/src/lib.rs b/components/decimal/src/lib.rs
index c43d03d9cca..73b2cdcac61 100644
--- a/components/decimal/src/lib.rs
+++ b/components/decimal/src/lib.rs
@@ -92,20 +92,18 @@ pub struct FixedDecimalFormat {
 
 impl FixedDecimalFormat {
     /// Creates a new [`FixedDecimalFormat`] from locale data and an options bag.
-    pub fn try_new<T: Into<Locale>, D: DataProvider<provider::DecimalSymbolsV1Marker> + ?Sized>(
+    pub fn try_new<
+        T: Into<Locale>,
+        D: ResourceProvider<provider::DecimalSymbolsV1Marker> + ?Sized,
+    >(
         locale: T,
         data_provider: &D,
         options: options::FixedDecimalFormatOptions,
     ) -> Result<Self, FixedDecimalFormatError> {
         let symbols = data_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: provider::key::SYMBOLS_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(locale.into().into()),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: locale.into().into(),
+                metadata: Default::default(),
             })?
             .take_payload()?;
         Ok(Self { options, symbols })
diff --git a/components/decimal/src/provider.rs b/components/decimal/src/provider.rs
index 64fd1767a0a..451d1849ad7 100644
--- a/components/decimal/src/provider.rs
+++ b/components/decimal/src/provider.rs
@@ -53,7 +53,7 @@ pub struct GroupingSizesV1 {
 }
 
 /// Symbols and metadata required for formatting a [`FixedDecimal`](crate::FixedDecimal).
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(DecimalSymbolsV1Marker = "decimal/symbols@1")]
 #[derive(Debug, PartialEq, Clone)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/icu/examples/tui.rs b/components/icu/examples/tui.rs
index 68309cebf16..baf776ff164 100644
--- a/components/icu/examples/tui.rs
+++ b/components/icu/examples/tui.rs
@@ -10,7 +10,7 @@
 use icu::calendar::Gregorian;
 use icu::datetime::DateTimeFormatOptions;
 use icu::locid::{macros::langid, Locale};
-use icu::plurals::{PluralCategory, PluralRuleType, PluralRules};
+use icu::plurals::{PluralCategory, PluralRules};
 use icu_datetime::{mock::zoned_datetime::MockZonedDateTime, ZonedDateTimeFormat};
 use icu_uniset::UnicodeSetBuilder;
 use std::env;
@@ -78,8 +78,8 @@ fn main(_argc: isize, _argv: *const *const u8) -> isize {
 
     {
         let en = langid!("en");
-        let pr = PluralRules::try_new(en, &provider, PluralRuleType::Cardinal)
-            .expect("Failed to create PluralRules.");
+        let pr =
+            PluralRules::try_new_cardinal(en, &provider).expect("Failed to create PluralRules.");
 
         match pr.select(email_count) {
             PluralCategory::One => print("Note: You have one unread email."),
diff --git a/components/locale_canonicalizer/src/locale_canonicalizer.rs b/components/locale_canonicalizer/src/locale_canonicalizer.rs
index 43d42c4a985..9520c5728d8 100644
--- a/components/locale_canonicalizer/src/locale_canonicalizer.rs
+++ b/components/locale_canonicalizer/src/locale_canonicalizer.rs
@@ -225,10 +225,10 @@ macro_rules! maximize_locale {
 }
 
 impl LocaleCanonicalizer {
-    /// A constructor which takes a [`DataProvider`] and creates a [`LocaleCanonicalizer`].
+    /// A constructor which takes a [`ResourceProvider`] and creates a [`LocaleCanonicalizer`].
     pub fn new<P>(provider: &P) -> Result<LocaleCanonicalizer, DataError>
     where
-        P: DataProvider<AliasesV1Marker> + DataProvider<LikelySubtagsV1Marker> + ?Sized,
+        P: ResourceProvider<AliasesV1Marker> + ResourceProvider<LikelySubtagsV1Marker> + ?Sized,
     {
         // The `rg` region override and `sd` regional subdivision keys may contain
         // language codes that require canonicalization.
@@ -237,11 +237,11 @@ impl LocaleCanonicalizer {
             Key::from_tinystr4_unchecked(tinystr4!("sd")),
         ];
         let aliases: DataPayload<AliasesV1Marker> = provider
-            .load_payload(&DataRequest::from(key::ALIASES_V1))?
+            .load_resource(&DataRequest::default())?
             .take_payload()?;
 
         let likely_subtags: DataPayload<LikelySubtagsV1Marker> = provider
-            .load_payload(&DataRequest::from(key::LIKELY_SUBTAGS_V1))?
+            .load_resource(&DataRequest::default())?
             .take_payload()?;
 
         Ok(LocaleCanonicalizer {
diff --git a/components/locale_canonicalizer/src/provider.rs b/components/locale_canonicalizer/src/provider.rs
index 5ed6c02cef4..e3dabb02110 100644
--- a/components/locale_canonicalizer/src/provider.rs
+++ b/components/locale_canonicalizer/src/provider.rs
@@ -8,7 +8,7 @@
 
 use alloc::vec::Vec;
 use icu_locid::LanguageIdentifier;
-use icu_provider::yoke::{self, *};
+use icu_provider::yoke;
 use litemap::LiteMap;
 use tinystr::{TinyStr4, TinyStr8};
 
@@ -23,7 +23,7 @@ pub mod key {
         resource_key!("locale_canonicalizer/likelysubtags@1");
 }
 
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(AliasesV1Marker = "locale_canonicalizer/aliases@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -67,7 +67,7 @@ pub struct AliasesV1 {
     pub subdivision: Vec<(TinyStr8, TinyStr8)>,
 }
 
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(LikelySubtagsV1Marker = "locale_canonicalizer/likelysubtags@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/plurals/benches/parser.rs b/components/plurals/benches/parser.rs
index 804eeed92e3..e9c27f6aa2a 100644
--- a/components/plurals/benches/parser.rs
+++ b/components/plurals/benches/parser.rs
@@ -18,16 +18,11 @@ fn parser(c: &mut Criterion) {
 
     let mut rules = vec![];
 
-    for langid in &fixture_data.langs {
-        let data_payload: DataPayload<icu_plurals::provider::PluralRulesV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: icu_plurals::provider::key::CARDINAL_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid.clone()),
-                    },
-                },
+    for langid in fixture_data.langs {
+        let data_payload: DataPayload<icu_plurals::provider::CardinalV1Marker> = provider
+            .load_resource(&DataRequest {
+                options: langid.into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
diff --git a/components/plurals/examples/elevator_floors.rs b/components/plurals/examples/elevator_floors.rs
index 1571de8956a..177dbc6c58a 100644
--- a/components/plurals/examples/elevator_floors.rs
+++ b/components/plurals/examples/elevator_floors.rs
@@ -10,7 +10,7 @@
 icu_benchmark_macros::static_setup!();
 
 use icu_locid_macros::langid;
-use icu_plurals::{PluralCategory, PluralRuleType, PluralRules};
+use icu_plurals::{PluralCategory, PluralRules};
 
 const VALUES: &[usize] = &[0, 2, 25, 1, 3, 2, 4, 10, 7, 0];
 
@@ -32,7 +32,7 @@ fn main(_argc: isize, _argv: *const *const u8) -> isize {
 
     {
         print("\n====== Elevator Floor (en) example ============", None);
-        let pr = PluralRules::try_new(lid, &provider, PluralRuleType::Ordinal)
+        let pr = PluralRules::try_new_ordinal(lid, &provider)
             .expect("Failed to create a PluralRules instance.");
 
         for value in VALUES {
diff --git a/components/plurals/examples/unread_emails.rs b/components/plurals/examples/unread_emails.rs
index 11d6257d258..f767bab57f7 100644
--- a/components/plurals/examples/unread_emails.rs
+++ b/components/plurals/examples/unread_emails.rs
@@ -10,7 +10,7 @@
 icu_benchmark_macros::static_setup!();
 
 use icu_locid_macros::langid;
-use icu_plurals::{PluralCategory, PluralRuleType, PluralRules};
+use icu_plurals::{PluralCategory, PluralRules};
 
 const VALUES: &[usize] = &[0, 2, 25, 1, 3, 2, 4, 10, 7, 0];
 
@@ -31,7 +31,7 @@ fn main(_argc: isize, _argv: *const *const u8) -> isize {
 
     {
         print("\n====== Unread Emails (en) example ============", None);
-        let pr = PluralRules::try_new(lid, &provider, PluralRuleType::Cardinal)
+        let pr = PluralRules::try_new_cardinal(lid, &provider)
             .expect("Failed to create a PluralRules instance.");
 
         for value in VALUES {
diff --git a/components/plurals/src/error.rs b/components/plurals/src/error.rs
index c9f9196bb78..c390b98784e 100644
--- a/components/plurals/src/error.rs
+++ b/components/plurals/src/error.rs
@@ -13,7 +13,7 @@ pub enum PluralRulesError {
     /// A parsing error for the plural rules.
     #[displaydoc("Parser error: {0}")]
     Parser(ParserError),
-    /// An error originating inside of the [`DataProvider`](icu_provider::DataProvider)
+    /// An error originating from [`icu_provider`].
     #[displaydoc("Data provider error: {0}")]
     DataProvider(DataError),
 }
diff --git a/components/plurals/src/lib.rs b/components/plurals/src/lib.rs
index 4edaa4a9a36..2ca74ca12b1 100644
--- a/components/plurals/src/lib.rs
+++ b/components/plurals/src/lib.rs
@@ -79,6 +79,8 @@ pub use error::PluralRulesError;
 use icu_locid::Locale;
 use icu_provider::prelude::*;
 pub use operands::PluralOperands;
+use provider::CardinalV1Marker;
+use provider::OrdinalV1Marker;
 use provider::PluralRulesV1Marker;
 use rules::runtime::test_rule;
 
@@ -294,31 +296,113 @@ impl PluralRules {
     /// ```
     ///
     /// [`type`]: PluralRuleType
-    /// [`data provider`]: icu_provider::DataProvider
+    /// [`data provider`]: icu_provider
     pub fn try_new<T: Into<Locale>, D>(
         locale: T,
         data_provider: &D,
         rule_type: PluralRuleType,
     ) -> Result<Self, PluralRulesError>
     where
-        D: DataProvider<PluralRulesV1Marker> + ?Sized,
+        D: ResourceProvider<CardinalV1Marker> + ResourceProvider<OrdinalV1Marker> + ?Sized,
+    {
+        match rule_type {
+            PluralRuleType::Cardinal => Self::try_new_cardinal(locale, data_provider),
+            PluralRuleType::Ordinal => Self::try_new_ordinal(locale, data_provider),
+        }
+    }
+
+    /// Constructs a new `PluralRules` for a given locale for cardinal numbers.
+    ///
+    /// Cardinal plural forms express quantities of units such as time, currency or distance,
+    /// used in conjunction with a number expressed in decimal digits (i.e. "2", not "two").
+    ///
+    /// For example, English has two forms for cardinals:
+    ///
+    /// * [`One`]: `1 day`
+    /// * [`Other`]: `0 days`, `2 days`, `10 days`, `0.3 days`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu::locid::macros::langid;
+    /// use icu::plurals::{PluralRules, PluralCategory};
+    ///
+    /// let lid = langid!("ru");
+    ///
+    /// let dp = icu_testdata::get_provider();
+    ///
+    /// let rules = PluralRules::try_new_cardinal(lid, &dp)
+    ///     .expect("Data should be present");
+    ///
+    /// assert_eq!(rules.select(2_usize), PluralCategory::Few);
+    /// ```
+    ///
+    /// [`One`]: PluralCategory::One
+    /// [`Other`]: PluralCategory::Other
+    pub fn try_new_cardinal<T: Into<Locale>, D>(
+        locale: T,
+        data_provider: &D,
+    ) -> Result<Self, PluralRulesError>
+    where
+        D: ResourceProvider<CardinalV1Marker> + ?Sized,
+    {
+        let locale = locale.into();
+        let rules = data_provider
+            .load_resource(&DataRequest {
+                options: locale.clone().into(),
+                metadata: Default::default(),
+            })?
+            .take_payload()?
+            .cast();
+        Self::new(locale, rules)
+    }
+
+    /// Constructs a new `PluralRules` for a given locale for ordinal numbers.
+    ///
+    /// Ordinal plural forms denote the order of items in a set and are always integers.
+    ///
+    /// For example, English has four forms for ordinals:
+    ///
+    /// * [`One`]: `1st floor`, `21st floor`, `101st floor`
+    /// * [`Two`]: `2nd floor`, `22nd floor`, `102nd floor`
+    /// * [`Few`]: `3rd floor`, `23rd floor`, `103rd floor`
+    /// * [`Other`]: `4th floor`, `11th floor`, `96th floor`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu::locid::macros::langid;
+    /// use icu::plurals::{PluralRules, PluralCategory};
+    ///
+    /// let lid = langid!("ru");
+    ///
+    /// let dp = icu_testdata::get_provider();
+    ///
+    /// let rules = PluralRules::try_new_ordinal(lid, &dp)
+    ///     .expect("Data should be present");
+    ///
+    /// assert_eq!(rules.select(2_usize), PluralCategory::Other);
+    /// ```
+    ///
+    /// [`One`]: PluralCategory::One
+    /// [`Two`]: PluralCategory::Two
+    /// [`Few`]: PluralCategory::Few
+    /// [`Other`]: PluralCategory::Other
+    pub fn try_new_ordinal<T: Into<Locale>, D>(
+        locale: T,
+        data_provider: &D,
+    ) -> Result<Self, PluralRulesError>
+    where
+        D: ResourceProvider<OrdinalV1Marker> + ?Sized,
     {
         let locale = locale.into();
-        let key = match rule_type {
-            PluralRuleType::Cardinal => provider::key::CARDINAL_V1,
-            PluralRuleType::Ordinal => provider::key::ORDINAL_V1,
-        };
         let rules = data_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(locale.clone().into()),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: locale.clone().into(),
+                metadata: Default::default(),
             })?
-            .take_payload()?;
+            .take_payload()?
+            .cast();
         Self::new(locale, rules)
     }
 
@@ -453,7 +537,7 @@ impl PluralRules {
 
     /// Lower-level constructor that allows constructing a [`PluralRules`] directly from
     /// data obtained from a provider.
-    pub fn new<T: Into<Locale>>(
+    fn new<T: Into<Locale>>(
         locale: T,
         rules: DataPayload<PluralRulesV1Marker>,
     ) -> Result<Self, PluralRulesError> {
diff --git a/components/plurals/src/provider.rs b/components/plurals/src/provider.rs
index dc719455e43..0fac9f5101c 100644
--- a/components/plurals/src/provider.rs
+++ b/components/plurals/src/provider.rs
@@ -7,7 +7,7 @@
 //! Read more about data providers: [`icu_provider`]
 
 use crate::rules::runtime::ast::Rule;
-use icu_provider::yoke::{self, *};
+use icu_provider::yoke;
 
 #[allow(missing_docs)] // TODO(#1029) - Add missing docs.
 pub mod key {
@@ -20,7 +20,11 @@ pub mod key {
 /// standard plural forms. If none of the rules match, the "other" category is assumed.
 ///
 /// More information: <https://unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules>
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(
+    PluralRulesV1Marker,
+    CardinalV1Marker = "plurals/cardinal@1",
+    OrdinalV1Marker = "plurals/ordinal@1"
+)]
 #[derive(Default, Clone, PartialEq, Debug)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/plurals/tests/plurals.rs b/components/plurals/tests/plurals.rs
index 3474cb0d192..9b65b2c8e27 100644
--- a/components/plurals/tests/plurals.rs
+++ b/components/plurals/tests/plurals.rs
@@ -4,9 +4,8 @@
 
 use icu_locid_macros::langid;
 use icu_plurals::{
-    provider::{self, PluralRulesV1Marker},
-    rules::runtime::ast::Rule,
-    PluralCategory, PluralRuleType, PluralRules,
+    provider::CardinalV1Marker, rules::runtime::ast::Rule, PluralCategory, PluralRuleType,
+    PluralRules,
 };
 use icu_provider::prelude::*;
 use zerovec::VarZeroVec;
@@ -28,15 +27,10 @@ fn test_static_provider_borrowed_rules() {
 
     let lid = langid!("en");
 
-    let rules: DataPayload<PluralRulesV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: provider::key::CARDINAL_V1,
-                options: ResourceOptions {
-                    variant: None,
-                    langid: Some(lid),
-                },
-            },
+    let rules: DataPayload<CardinalV1Marker> = provider
+        .load_resource(&DataRequest {
+            options: lid.into(),
+            metadata: Default::default(),
         })
         .expect("Failed to load payload")
         .take_payload()
diff --git a/components/properties/src/maps.rs b/components/properties/src/maps.rs
index fe991a26b4d..04d0846ed85 100644
--- a/components/properties/src/maps.rs
+++ b/components/properties/src/maps.rs
@@ -24,20 +24,11 @@ pub type CodePointMapResult<T> =
 
 fn get_cp_map<D, T>(provider: &D, resc_key: ResourceKey) -> CodePointMapResult<T>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<T>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<T>> + ?Sized,
     T: TrieValue,
 {
-    let data_req = DataRequest {
-        resource_path: ResourcePath {
-            key: resc_key,
-            options: ResourceOptions {
-                variant: None,
-                langid: None,
-            },
-        },
-    };
-
-    let resp: DataResponse<UnicodePropertyMapV1Marker<T>> = provider.load_payload(&data_req)?;
+    let resp: DataResponse<UnicodePropertyMapV1Marker<T>> =
+        provider.load_payload(resc_key, &Default::default())?;
 
     let property_payload: DataPayload<UnicodePropertyMapV1Marker<T>> = resp.take_payload()?;
     Ok(property_payload)
@@ -65,7 +56,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_general_category<D>(provider: &D) -> CodePointMapResult<GeneralCategory>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<GeneralCategory>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<GeneralCategory>> + ?Sized,
 {
     get_cp_map(provider, key::GENERAL_CATEGORY_V1)
 }
@@ -92,7 +83,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_script<D>(provider: &D) -> CodePointMapResult<Script>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<Script>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<Script>> + ?Sized,
 {
     get_cp_map(provider, key::SCRIPT_V1)
 }
@@ -116,7 +107,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_east_asian_width<D>(provider: &D) -> CodePointMapResult<EastAsianWidth>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<EastAsianWidth>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<EastAsianWidth>> + ?Sized,
 {
     get_cp_map(provider, key::EAST_ASIAN_WIDTH_V1)
 }
@@ -140,7 +131,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_line_break<D>(provider: &D) -> CodePointMapResult<LineBreak>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<LineBreak>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<LineBreak>> + ?Sized,
 {
     get_cp_map(provider, key::LINE_BREAK_V1)
 }
@@ -164,7 +155,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_grapheme_cluster_break<D>(provider: &D) -> CodePointMapResult<GraphemeClusterBreak>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<GraphemeClusterBreak>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<GraphemeClusterBreak>> + ?Sized,
 {
     get_cp_map(provider, key::GRAPHEME_CLUSTER_BREAK_V1)
 }
@@ -188,7 +179,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_word_break<D>(provider: &D) -> CodePointMapResult<WordBreak>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<WordBreak>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<WordBreak>> + ?Sized,
 {
     get_cp_map(provider, key::WORD_BREAK_V1)
 }
@@ -212,7 +203,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_sentence_break<D>(provider: &D) -> CodePointMapResult<SentenceBreak>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<SentenceBreak>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<SentenceBreak>> + ?Sized,
 {
     get_cp_map(provider, key::SENTENCE_BREAK_V1)
 }
@@ -236,7 +227,7 @@ where
 /// [`CodePointTrie`]: icu_codepointtrie::CodePointTrie
 pub fn get_canonical_combining_class<D>(provider: &D) -> CodePointMapResult<CanonicalCombiningClass>
 where
-    D: DataProvider<UnicodePropertyMapV1Marker<CanonicalCombiningClass>> + ?Sized,
+    D: DynProvider<UnicodePropertyMapV1Marker<CanonicalCombiningClass>> + ?Sized,
 {
     get_cp_map(provider, key::CANONICAL_COMBINING_CLASS_V1)
 }
diff --git a/components/properties/src/provider.rs b/components/properties/src/provider.rs
index 35892c59d32..fa83cff07e3 100644
--- a/components/properties/src/provider.rs
+++ b/components/properties/src/provider.rs
@@ -349,7 +349,7 @@ pub mod key {
 //
 
 /// A set of characters with a particular property.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(UnicodePropertyV1Marker)]
 #[derive(Debug, Eq, PartialEq, Clone)]
 #[cfg_attr(
     feature = "provider_serde",
@@ -425,7 +425,7 @@ impl<T: TrieValue> icu_provider::DataMarker for UnicodePropertyMapV1Marker<T> {
 //
 
 /// A data structure efficiently storing `Script` and `Script_Extensions` property data.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(ScriptExtensionsPropertyV1Marker)]
 #[derive(Debug, Eq, PartialEq)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/properties/src/sets.rs b/components/properties/src/sets.rs
index 91f78f5e9c0..d5dfe70e39f 100644
--- a/components/properties/src/sets.rs
+++ b/components/properties/src/sets.rs
@@ -25,19 +25,10 @@ pub type UnisetResult = Result<DataPayload<UnicodePropertyV1Marker>, PropertiesE
 // helper fn
 fn get_uniset<D>(provider: &D, resc_key: ResourceKey) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
-{
-    let data_req = DataRequest {
-        resource_path: ResourcePath {
-            key: resc_key,
-            options: ResourceOptions {
-                variant: None,
-                langid: None,
-            },
-        },
-    };
-
-    let resp: DataResponse<UnicodePropertyV1Marker> = provider.load_payload(&data_req)?;
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
+{
+    let resp: DataResponse<UnicodePropertyV1Marker> =
+        provider.load_payload(resc_key, &Default::default())?;
 
     let property_payload: DataPayload<UnicodePropertyV1Marker> = resp.take_payload()?;
     Ok(property_payload)
@@ -68,7 +59,7 @@ where
 /// ```
 pub fn get_ascii_hex_digit<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::ASCII_HEX_DIGIT_V1)
 }
@@ -77,7 +68,7 @@ where
 /// This is defined for POSIX compatibility.
 pub fn get_alnum<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::ALNUM_V1)
 }
@@ -103,7 +94,7 @@ where
 /// ```
 pub fn get_alphabetic<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::ALPHABETIC_V1)
 }
@@ -128,7 +119,7 @@ where
 /// ```
 pub fn get_bidi_control<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::BIDI_CONTROL_V1)
 }
@@ -154,7 +145,7 @@ where
 /// ```
 pub fn get_bidi_mirrored<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::BIDI_MIRRORED_V1)
 }
@@ -162,7 +153,7 @@ where
 /// Horizontal whitespace characters
 pub fn get_blank<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::BLANK_V1)
 }
@@ -186,7 +177,7 @@ where
 /// ```
 pub fn get_cased<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CASED_V1)
 }
@@ -210,7 +201,7 @@ where
 /// ```
 pub fn get_case_ignorable<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CASE_IGNORABLE_V1)
 }
@@ -219,7 +210,7 @@ where
 /// See <https://unicode.org/Public/UNIDATA/CompositionExclusions.txt>
 pub fn get_full_composition_exclusion<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::FULL_COMPOSITION_EXCLUSION_V1)
 }
@@ -243,7 +234,7 @@ where
 /// ```
 pub fn get_changes_when_casefolded<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CHANGES_WHEN_CASEFOLDED_V1)
 }
@@ -251,7 +242,7 @@ where
 /// Characters which may change when they undergo case mapping
 pub fn get_changes_when_casemapped<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CHANGES_WHEN_CASEMAPPED_V1)
 }
@@ -275,7 +266,7 @@ where
 /// ```
 pub fn get_changes_when_nfkc_casefolded<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CHANGES_WHEN_NFKC_CASEFOLDED_V1)
 }
@@ -299,7 +290,7 @@ where
 /// ```
 pub fn get_changes_when_lowercased<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CHANGES_WHEN_LOWERCASED_V1)
 }
@@ -323,7 +314,7 @@ where
 /// ```
 pub fn get_changes_when_titlecased<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CHANGES_WHEN_TITLECASED_V1)
 }
@@ -347,7 +338,7 @@ where
 /// ```
 pub fn get_changes_when_uppercased<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CHANGES_WHEN_UPPERCASED_V1)
 }
@@ -373,7 +364,7 @@ where
 /// ```
 pub fn get_dash<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::DASH_V1)
 }
@@ -398,7 +389,7 @@ where
 /// ```
 pub fn get_deprecated<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::DEPRECATED_V1)
 }
@@ -425,7 +416,7 @@ where
 /// ```
 pub fn get_default_ignorable_code_point<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::DEFAULT_IGNORABLE_CODE_POINT_V1)
 }
@@ -449,7 +440,7 @@ where
 /// ```
 pub fn get_diacritic<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::DIACRITIC_V1)
 }
@@ -473,7 +464,7 @@ where
 /// ```
 pub fn get_emoji_modifier_base<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EMOJI_MODIFIER_BASE_V1)
 }
@@ -500,7 +491,7 @@ where
 /// ```
 pub fn get_emoji_component<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EMOJI_COMPONENT_V1)
 }
@@ -524,7 +515,7 @@ where
 /// ```
 pub fn get_emoji_modifier<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EMOJI_MODIFIER_V1)
 }
@@ -548,7 +539,7 @@ where
 /// ```
 pub fn get_emoji<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EMOJI_V1)
 }
@@ -572,7 +563,7 @@ where
 /// ```
 pub fn get_emoji_presentation<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EMOJI_PRESENTATION_V1)
 }
@@ -598,7 +589,7 @@ where
 /// ```
 pub fn get_extender<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EXTENDER_V1)
 }
@@ -623,7 +614,7 @@ where
 /// ```
 pub fn get_extended_pictographic<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::EXTENDED_PICTOGRAPHIC_V1)
 }
@@ -632,7 +623,7 @@ where
 /// This is defined for POSIX compatibility.
 pub fn get_graph<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::GRAPH_V1)
 }
@@ -658,7 +649,7 @@ where
 /// ```
 pub fn get_grapheme_base<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::GRAPHEME_BASE_V1)
 }
@@ -684,7 +675,7 @@ where
 /// ```
 pub fn get_grapheme_extend<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::GRAPHEME_EXTEND_V1)
 }
@@ -693,7 +684,7 @@ where
 /// cluster boundaries.
 pub fn get_grapheme_link<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::GRAPHEME_LINK_V1)
 }
@@ -722,7 +713,7 @@ where
 /// ```
 pub fn get_hex_digit<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::HEX_DIGIT_V1)
 }
@@ -731,7 +722,7 @@ where
 /// words, plus the Katakana middle dot.
 pub fn get_hyphen<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::HYPHEN_V1)
 }
@@ -762,7 +753,7 @@ where
 /// ```
 pub fn get_id_continue<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::ID_CONTINUE_V1)
 }
@@ -787,7 +778,7 @@ where
 /// ```
 pub fn get_ideographic<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::IDEOGRAPHIC_V1)
 }
@@ -817,7 +808,7 @@ where
 /// ```
 pub fn get_id_start<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::ID_START_V1)
 }
@@ -841,7 +832,7 @@ where
 /// ```
 pub fn get_ids_binary_operator<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::IDS_BINARY_OPERATOR_V1)
 }
@@ -868,7 +859,7 @@ where
 /// ```
 pub fn get_ids_trinary_operator<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::IDS_TRINARY_OPERATOR_V1)
 }
@@ -894,7 +885,7 @@ where
 /// ```
 pub fn get_join_control<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::JOIN_CONTROL_V1)
 }
@@ -918,7 +909,7 @@ where
 /// ```
 pub fn get_logical_order_exception<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::LOGICAL_ORDER_EXCEPTION_V1)
 }
@@ -942,7 +933,7 @@ where
 /// ```
 pub fn get_lowercase<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::LOWERCASE_V1)
 }
@@ -970,7 +961,7 @@ where
 /// ```
 pub fn get_math<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::MATH_V1)
 }
@@ -995,7 +986,7 @@ where
 /// ```
 pub fn get_noncharacter_code_point<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::NONCHARACTER_CODE_POINT_V1)
 }
@@ -1003,7 +994,7 @@ where
 /// Characters that are inert under NFC, i.e., they do not interact with adjacent characters
 pub fn get_nfc_inert<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::NFC_INERT_V1)
 }
@@ -1011,7 +1002,7 @@ where
 /// Characters that are inert under NFD, i.e., they do not interact with adjacent characters
 pub fn get_nfd_inert<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::NFD_INERT_V1)
 }
@@ -1019,7 +1010,7 @@ where
 /// Characters that are inert under NFKC, i.e., they do not interact with adjacent characters
 pub fn get_nfkc_inert<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::NFKC_INERT_V1)
 }
@@ -1027,7 +1018,7 @@ where
 /// Characters that are inert under NFKD, i.e., they do not interact with adjacent characters
 pub fn get_nfkd_inert<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::NFKD_INERT_V1)
 }
@@ -1054,7 +1045,7 @@ where
 /// ```
 pub fn get_pattern_syntax<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::PATTERN_SYNTAX_V1)
 }
@@ -1082,7 +1073,7 @@ where
 /// ```
 pub fn get_pattern_white_space<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::PATTERN_WHITE_SPACE_V1)
 }
@@ -1091,7 +1082,7 @@ where
 /// other characters, usually digits.
 pub fn get_prepended_concatenation_mark<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::PREPENDED_CONCATENATION_MARK_V1)
 }
@@ -1100,7 +1091,7 @@ where
 /// This is defined for POSIX compatibility.
 pub fn get_print<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::PRINT_V1)
 }
@@ -1125,7 +1116,7 @@ where
 /// ```
 pub fn get_quotation_mark<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::QUOTATION_MARK_V1)
 }
@@ -1149,7 +1140,7 @@ where
 /// ```
 pub fn get_radical<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::RADICAL_V1)
 }
@@ -1174,7 +1165,7 @@ where
 /// ```
 pub fn get_regional_indicator<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::REGIONAL_INDICATOR_V1)
 }
@@ -1199,7 +1190,7 @@ where
 /// ```
 pub fn get_soft_dotted<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::SOFT_DOTTED_V1)
 }
@@ -1208,7 +1199,7 @@ where
 /// sequences
 pub fn get_segment_starter<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::SEGMENT_STARTER_V1)
 }
@@ -1217,7 +1208,7 @@ where
 /// mapping
 pub fn get_case_sensitive<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::CASE_SENSITIVE_V1)
 }
@@ -1244,7 +1235,7 @@ where
 /// ```
 pub fn get_sentence_terminal<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::SENTENCE_TERMINAL_V1)
 }
@@ -1271,7 +1262,7 @@ where
 /// ```
 pub fn get_terminal_punctuation<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::TERMINAL_PUNCTUATION_V1)
 }
@@ -1296,7 +1287,7 @@ where
 /// ```
 pub fn get_unified_ideograph<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::UNIFIED_IDEOGRAPH_V1)
 }
@@ -1320,7 +1311,7 @@ where
 /// ```
 pub fn get_uppercase<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::UPPERCASE_V1)
 }
@@ -1347,7 +1338,7 @@ where
 /// ```
 pub fn get_variation_selector<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::VARIATION_SELECTOR_V1)
 }
@@ -1374,7 +1365,7 @@ where
 /// ```
 pub fn get_white_space<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::WHITE_SPACE_V1)
 }
@@ -1383,7 +1374,7 @@ where
 /// This is defined for POSIX compatibility.
 pub fn get_xdigit<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::XDIGIT_V1)
 }
@@ -1412,7 +1403,7 @@ where
 /// ```
 pub fn get_xid_continue<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::XID_CONTINUE_V1)
 }
@@ -1442,7 +1433,7 @@ where
 /// ```
 pub fn get_xid_start<D>(provider: &D) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     get_uniset(provider, key::XID_START_V1)
 }
@@ -1456,7 +1447,7 @@ where
 /// [`UnicodeSet`]: icu_uniset::UnicodeSet
 pub fn get_for_general_category<D>(provider: &D, enum_val: GeneralCategory) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     let key = match enum_val {
         GeneralCategory::Control => key::GENERAL_CATEGORY_CONTROL_V1,
@@ -1501,7 +1492,7 @@ pub fn get_for_general_category_group<D>(
     enum_val: GeneralCategoryGroup,
 ) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     let key = match enum_val {
         GeneralCategoryGroup::Other => key::GENERAL_CATEGORY_OTHER_V1,
@@ -1554,7 +1545,7 @@ where
 /// [`UnicodeSet`]: icu_uniset::UnicodeSet
 pub fn get_for_script<D>(provider: &D, enum_val: Script) -> UnisetResult
 where
-    D: DataProvider<UnicodePropertyV1Marker> + ?Sized,
+    D: DynProvider<UnicodePropertyV1Marker> + ?Sized,
 {
     let key = match enum_val {
         Script::Adlam => key::SCRIPT_ADLAM_V1,
diff --git a/experimental/list_formatter/src/list_formatter.rs b/experimental/list_formatter/src/list_formatter.rs
index 3c2de24e241..0fd067ed5c9 100644
--- a/experimental/list_formatter/src/list_formatter.rs
+++ b/experimental/list_formatter/src/list_formatter.rs
@@ -49,26 +49,24 @@ impl ListFormatter {
     /// [`LIST_FORMAT_UNIT_V1`](crate::provider::key::LIST_FORMAT_UNIT_V1).
     /// An error is returned if the key or language are not available, or if there were any
     /// deserialization errors.
-    pub fn try_new<T: Into<Locale>, D: DataProvider<ListFormatterPatternsV1Marker> + ?Sized>(
+    pub fn try_new<T: Into<Locale>, D: DynProvider<ListFormatterPatternsV1Marker> + ?Sized>(
         locale: T,
         data_provider: &D,
         type_: ListType,
         style: ListStyle,
     ) -> Result<Self, DataError> {
         let data = data_provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: match type_ {
-                        ListType::And => key::LIST_FORMAT_AND_V1,
-                        ListType::Or => key::LIST_FORMAT_OR_V1,
-                        ListType::Unit => key::LIST_FORMAT_UNIT_V1,
-                    },
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(locale.into().into()),
-                    },
+            .load_payload(
+                match type_ {
+                    ListType::And => key::LIST_FORMAT_AND_V1,
+                    ListType::Or => key::LIST_FORMAT_OR_V1,
+                    ListType::Unit => key::LIST_FORMAT_UNIT_V1,
                 },
-            })?
+                &DataRequest {
+                    options: locale.into().into(),
+                    metadata: Default::default(),
+                },
+            )?
             .take_payload()?;
         Ok(Self { data, style })
     }
diff --git a/experimental/list_formatter/src/provider.rs b/experimental/list_formatter/src/provider.rs
index 70dd11092dd..96c6e73b7a5 100644
--- a/experimental/list_formatter/src/provider.rs
+++ b/experimental/list_formatter/src/provider.rs
@@ -28,7 +28,7 @@ pub mod key {
 }
 
 /// Symbols and metadata required for [`ListFormatter`](crate::ListFormatter)
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(ListFormatterPatternsV1Marker)]
 #[derive(Debug)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/experimental/segmenter/src/line_breaker.rs b/experimental/segmenter/src/line_breaker.rs
index 7c74e018a48..4b6795a733b 100644
--- a/experimental/segmenter/src/line_breaker.rs
+++ b/experimental/segmenter/src/line_breaker.rs
@@ -112,7 +112,7 @@ pub struct LineBreakSegmenter {
 impl LineBreakSegmenter {
     pub fn try_new<D>(provider: &D) -> Result<Self, DataError>
     where
-        D: DataProvider<LineBreakDataV1Marker> + ?Sized,
+        D: ResourceProvider<LineBreakDataV1Marker> + ?Sized,
     {
         Self::try_new_with_options(provider, Default::default())
     }
@@ -122,15 +122,10 @@ impl LineBreakSegmenter {
         options: LineBreakOptions,
     ) -> Result<Self, DataError>
     where
-        D: DataProvider<LineBreakDataV1Marker> + ?Sized,
+        D: ResourceProvider<LineBreakDataV1Marker> + ?Sized,
     {
         let payload = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::LINE_BREAK_DATA_V1,
-                    options: Default::default(),
-                },
-            })?
+            .load_resource(&DataRequest::default())?
             .take_payload()?;
         Ok(Self { options, payload })
     }
diff --git a/experimental/segmenter/src/provider.rs b/experimental/segmenter/src/provider.rs
index efd25703953..e2092cff85c 100644
--- a/experimental/segmenter/src/provider.rs
+++ b/experimental/segmenter/src/provider.rs
@@ -23,7 +23,7 @@ pub mod key {
 }
 
 /// Pre-processed Unicode data in the form of tables to be used for line breaking.
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(LineBreakDataV1Marker = "segmenter/line@1")]
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/experimental/segmenter_lstm/src/structs.rs b/experimental/segmenter_lstm/src/structs.rs
index 4a34f70d9df..7620be2f59a 100644
--- a/experimental/segmenter_lstm/src/structs.rs
+++ b/experimental/segmenter_lstm/src/structs.rs
@@ -7,7 +7,6 @@ use ndarray::Array1;
 use ndarray::Array2;
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
-use yoke::{Yokeable, ZeroCopyFrom};
 
 /// 'LstmData' is a struct that store a LSTM model. Its attributes are:
 /// `model`: name of the model
@@ -16,7 +15,7 @@ use yoke::{Yokeable, ZeroCopyFrom};
 /// `mat2` - `mat4`: the matrices associated with forward LSTM layer (embedding to hunits, hunits to hunits, and bias respectively)
 /// `mat5` - `mat7`: the matrices associated with backward LSTM layer (embedding to hunits, hunits to hunits, and bias respectively)
 /// `mat8` - `mat9`: the matrices associated with output layer (weight and bias term respectiely)
-#[icu_provider::data_struct]
+#[icu_provider::data_struct(LstmDataMarker)]
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]
 #[yoke(cloning_zcf)]
 pub struct LstmData<'data> {
diff --git a/ffi/diplomat/c/examples/pluralrules/test.c b/ffi/diplomat/c/examples/pluralrules/test.c
index 6f2ef109bf3..9566a2d0eab 100644
--- a/ffi/diplomat/c/examples/pluralrules/test.c
+++ b/ffi/diplomat/c/examples/pluralrules/test.c
@@ -15,7 +15,7 @@ int main() {
         return 1;
     }
     ICU4XDataProvider* provider = result.provider;
-    ICU4XCreatePluralRulesResult plural_result = ICU4XPluralRules_try_new(locale, provider, ICU4XPluralRuleType_Cardinal);
+    ICU4XCreatePluralRulesResult plural_result = ICU4XPluralRules_try_new_cardinal(locale, provider);
     if (!plural_result.success) {
         printf("Failed to create PluralRules\n");
         return 1;
diff --git a/ffi/diplomat/c/include/ICU4XPluralRuleType.h b/ffi/diplomat/c/include/ICU4XPluralRuleType.h
deleted file mode 100644
index 0ea817ecc25..00000000000
--- a/ffi/diplomat/c/include/ICU4XPluralRuleType.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef ICU4XPluralRuleType_H
-#define ICU4XPluralRuleType_H
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "diplomat_runtime.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum ICU4XPluralRuleType {
-  ICU4XPluralRuleType_Cardinal = 0,
-  ICU4XPluralRuleType_Ordinal = 1,
-} ICU4XPluralRuleType;
-
-void ICU4XPluralRuleType_destroy(ICU4XPluralRuleType* self);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/ffi/diplomat/c/include/ICU4XPluralRules.h b/ffi/diplomat/c/include/ICU4XPluralRules.h
index f6723c30a1f..89c04de4dfc 100644
--- a/ffi/diplomat/c/include/ICU4XPluralRules.h
+++ b/ffi/diplomat/c/include/ICU4XPluralRules.h
@@ -13,13 +13,14 @@ extern "C" {
 typedef struct ICU4XPluralRules ICU4XPluralRules;
 #include "ICU4XLocale.h"
 #include "ICU4XDataProvider.h"
-#include "ICU4XPluralRuleType.h"
 #include "ICU4XCreatePluralRulesResult.h"
 #include "ICU4XPluralOperands.h"
 #include "ICU4XPluralCategory.h"
 #include "ICU4XPluralCategories.h"
 
-ICU4XCreatePluralRulesResult ICU4XPluralRules_try_new(const ICU4XLocale* locale, const ICU4XDataProvider* provider, ICU4XPluralRuleType ty);
+ICU4XCreatePluralRulesResult ICU4XPluralRules_try_new_cardinal(const ICU4XLocale* locale, const ICU4XDataProvider* provider);
+
+ICU4XCreatePluralRulesResult ICU4XPluralRules_try_new_ordinal(const ICU4XLocale* locale, const ICU4XDataProvider* provider);
 
 ICU4XPluralCategory ICU4XPluralRules_select(const ICU4XPluralRules* self, ICU4XPluralOperands op);
 
diff --git a/ffi/diplomat/cpp/docs/source/pluralrules_ffi.rst b/ffi/diplomat/cpp/docs/source/pluralrules_ffi.rst
index 45cd7f41569..18957301a29 100644
--- a/ffi/diplomat/cpp/docs/source/pluralrules_ffi.rst
+++ b/ffi/diplomat/cpp/docs/source/pluralrules_ffi.rst
@@ -67,21 +67,17 @@
 
         FFI version of ``PluralOperands::from_str()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralOperands.html#method.from_str>`__ for more details.
 
-.. cpp:enum-struct:: ICU4XPluralRuleType
-
-    FFI version of ``PluralRuleType``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/enum.PluralRuleType.html>`__ for more details.
-
-    .. cpp:enumerator:: Cardinal
-
-    .. cpp:enumerator:: Ordinal
-
 .. cpp:class:: ICU4XPluralRules
 
     FFI version of ``PluralRules``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html>`__ for more details.
 
-    .. cpp:function:: static ICU4XCreatePluralRulesResult try_new(const ICU4XLocale& locale, const ICU4XDataProvider& provider, ICU4XPluralRuleType ty)
+    .. cpp:function:: static ICU4XCreatePluralRulesResult try_new_cardinal(const ICU4XLocale& locale, const ICU4XDataProvider& provider)
+
+        FFI version of ``PluralRules::try_new_cardinal()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new>`__ for more details.
+
+    .. cpp:function:: static ICU4XCreatePluralRulesResult try_new_ordinal(const ICU4XLocale& locale, const ICU4XDataProvider& provider)
 
-        FFI version of ``PluralRules::try_new()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new>`__ for more details.
+        FFI version of ``PluralRules::try_new_ordinal()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new>`__ for more details.
 
     .. cpp:function:: ICU4XPluralCategory select(ICU4XPluralOperands op) const
 
diff --git a/ffi/diplomat/cpp/examples/pluralrules/test.cpp b/ffi/diplomat/cpp/examples/pluralrules/test.cpp
index 67346dde532..d43e4a20e29 100644
--- a/ffi/diplomat/cpp/examples/pluralrules/test.cpp
+++ b/ffi/diplomat/cpp/examples/pluralrules/test.cpp
@@ -12,7 +12,7 @@ int main() {
     ICU4XLocale locale = ICU4XLocale::create("ar").value();
     std::cout << "Running test for locale " << locale.tostring().ok().value() << std::endl;
     ICU4XDataProvider dp = ICU4XDataProvider::create_fs(path).provider.value();
-    ICU4XPluralRules pr = ICU4XPluralRules::try_new(locale, dp, ICU4XPluralRuleType::Cardinal).rules.value();
+    ICU4XPluralRules pr = ICU4XPluralRules::try_new_cardinal(locale, dp).rules.value();
 
     ICU4XPluralOperands op = { .i = 3 };
     ICU4XPluralCategory cat = pr.select(op);
diff --git a/ffi/diplomat/cpp/include/ICU4XPluralRuleType.h b/ffi/diplomat/cpp/include/ICU4XPluralRuleType.h
deleted file mode 100644
index 0ea817ecc25..00000000000
--- a/ffi/diplomat/cpp/include/ICU4XPluralRuleType.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef ICU4XPluralRuleType_H
-#define ICU4XPluralRuleType_H
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "diplomat_runtime.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum ICU4XPluralRuleType {
-  ICU4XPluralRuleType_Cardinal = 0,
-  ICU4XPluralRuleType_Ordinal = 1,
-} ICU4XPluralRuleType;
-
-void ICU4XPluralRuleType_destroy(ICU4XPluralRuleType* self);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/ffi/diplomat/cpp/include/ICU4XPluralRuleType.hpp b/ffi/diplomat/cpp/include/ICU4XPluralRuleType.hpp
deleted file mode 100644
index 613814496e2..00000000000
--- a/ffi/diplomat/cpp/include/ICU4XPluralRuleType.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef ICU4XPluralRuleType_HPP
-#define ICU4XPluralRuleType_HPP
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <algorithm>
-#include <memory>
-#include <variant>
-#include <optional>
-#include "diplomat_runtime.hpp"
-
-namespace capi {
-#include "ICU4XPluralRuleType.h"
-}
-
-
-
-/**
- * FFI version of `PluralRuleType`.
- * See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/enum.PluralRuleType.html) for more details.
- */
-enum struct ICU4XPluralRuleType {
-  Cardinal = 0,
-  Ordinal = 1,
-};
-
-#endif
diff --git a/ffi/diplomat/cpp/include/ICU4XPluralRules.h b/ffi/diplomat/cpp/include/ICU4XPluralRules.h
index f6723c30a1f..89c04de4dfc 100644
--- a/ffi/diplomat/cpp/include/ICU4XPluralRules.h
+++ b/ffi/diplomat/cpp/include/ICU4XPluralRules.h
@@ -13,13 +13,14 @@ extern "C" {
 typedef struct ICU4XPluralRules ICU4XPluralRules;
 #include "ICU4XLocale.h"
 #include "ICU4XDataProvider.h"
-#include "ICU4XPluralRuleType.h"
 #include "ICU4XCreatePluralRulesResult.h"
 #include "ICU4XPluralOperands.h"
 #include "ICU4XPluralCategory.h"
 #include "ICU4XPluralCategories.h"
 
-ICU4XCreatePluralRulesResult ICU4XPluralRules_try_new(const ICU4XLocale* locale, const ICU4XDataProvider* provider, ICU4XPluralRuleType ty);
+ICU4XCreatePluralRulesResult ICU4XPluralRules_try_new_cardinal(const ICU4XLocale* locale, const ICU4XDataProvider* provider);
+
+ICU4XCreatePluralRulesResult ICU4XPluralRules_try_new_ordinal(const ICU4XLocale* locale, const ICU4XDataProvider* provider);
 
 ICU4XPluralCategory ICU4XPluralRules_select(const ICU4XPluralRules* self, ICU4XPluralOperands op);
 
diff --git a/ffi/diplomat/cpp/include/ICU4XPluralRules.hpp b/ffi/diplomat/cpp/include/ICU4XPluralRules.hpp
index 2b2b68eaf31..6d584babdda 100644
--- a/ffi/diplomat/cpp/include/ICU4XPluralRules.hpp
+++ b/ffi/diplomat/cpp/include/ICU4XPluralRules.hpp
@@ -15,7 +15,6 @@ namespace capi {
 
 class ICU4XLocale;
 class ICU4XDataProvider;
-#include "ICU4XPluralRuleType.hpp"
 struct ICU4XCreatePluralRulesResult;
 struct ICU4XPluralOperands;
 #include "ICU4XPluralCategory.hpp"
@@ -33,10 +32,16 @@ class ICU4XPluralRules {
  public:
 
   /**
-   * FFI version of `PluralRules::try_new()`.
+   * FFI version of `PluralRules::try_new_cardinal()`.
    * See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new) for more details.
    */
-  static ICU4XCreatePluralRulesResult try_new(const ICU4XLocale& locale, const ICU4XDataProvider& provider, ICU4XPluralRuleType ty);
+  static ICU4XCreatePluralRulesResult try_new_cardinal(const ICU4XLocale& locale, const ICU4XDataProvider& provider);
+
+  /**
+   * FFI version of `PluralRules::try_new_ordinal()`.
+   * See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new) for more details.
+   */
+  static ICU4XCreatePluralRulesResult try_new_ordinal(const ICU4XLocale& locale, const ICU4XDataProvider& provider);
 
   /**
    * FFI version of `PluralRules::select()`.
@@ -65,8 +70,19 @@ class ICU4XPluralRules {
 #include "ICU4XPluralOperands.hpp"
 #include "ICU4XPluralCategories.hpp"
 
-inline ICU4XCreatePluralRulesResult ICU4XPluralRules::try_new(const ICU4XLocale& locale, const ICU4XDataProvider& provider, ICU4XPluralRuleType ty) {
-  capi::ICU4XCreatePluralRulesResult diplomat_raw_struct_out_value = capi::ICU4XPluralRules_try_new(locale.AsFFI(), provider.AsFFI(), static_cast<capi::ICU4XPluralRuleType>(ty));
+inline ICU4XCreatePluralRulesResult ICU4XPluralRules::try_new_cardinal(const ICU4XLocale& locale, const ICU4XDataProvider& provider) {
+  capi::ICU4XCreatePluralRulesResult diplomat_raw_struct_out_value = capi::ICU4XPluralRules_try_new_cardinal(locale.AsFFI(), provider.AsFFI());
+  auto diplomat_optional_raw_out_value_rules = diplomat_raw_struct_out_value.rules;
+  std::optional<ICU4XPluralRules> diplomat_optional_out_value_rules;
+  if (diplomat_optional_raw_out_value_rules != nullptr) {
+    diplomat_optional_out_value_rules = ICU4XPluralRules(diplomat_optional_raw_out_value_rules);
+  } else {
+    diplomat_optional_out_value_rules = std::nullopt;
+  }
+  return ICU4XCreatePluralRulesResult{ .rules = std::move(diplomat_optional_out_value_rules), .success = std::move(diplomat_raw_struct_out_value.success) };
+}
+inline ICU4XCreatePluralRulesResult ICU4XPluralRules::try_new_ordinal(const ICU4XLocale& locale, const ICU4XDataProvider& provider) {
+  capi::ICU4XCreatePluralRulesResult diplomat_raw_struct_out_value = capi::ICU4XPluralRules_try_new_ordinal(locale.AsFFI(), provider.AsFFI());
   auto diplomat_optional_raw_out_value_rules = diplomat_raw_struct_out_value.rules;
   std::optional<ICU4XPluralRules> diplomat_optional_out_value_rules;
   if (diplomat_optional_raw_out_value_rules != nullptr) {
diff --git a/ffi/diplomat/src/decimal.rs b/ffi/diplomat/src/decimal.rs
index 9db7c942258..1f19d55e813 100644
--- a/ffi/diplomat/src/decimal.rs
+++ b/ffi/diplomat/src/decimal.rs
@@ -12,8 +12,8 @@ pub mod ffi {
         FixedDecimalFormat,
     };
     use icu_locid::Locale;
-    use icu_provider::prelude::DataProvider;
     use icu_provider::struct_provider::AnyPayloadProvider;
+    use icu_provider::ResourceProvider;
     use writeable::Writeable;
 
     use crate::{
@@ -95,7 +95,7 @@ pub mod ffi {
             options: ICU4XFixedDecimalFormatOptions,
         ) -> DiplomatResult<Box<ICU4XFixedDecimalFormat>, ()>
         where
-            D: DataProvider<DecimalSymbolsV1Marker> + ?Sized,
+            D: ResourceProvider<DecimalSymbolsV1Marker> + ?Sized,
         {
             let langid = locale.0.as_ref().clone();
 
diff --git a/ffi/diplomat/src/pluralrules.rs b/ffi/diplomat/src/pluralrules.rs
index d8088eb9229..42fc363a052 100644
--- a/ffi/diplomat/src/pluralrules.rs
+++ b/ffi/diplomat/src/pluralrules.rs
@@ -8,10 +8,7 @@ pub mod ffi {
 
     use alloc::boxed::Box;
 
-    use icu_plurals::{
-        provider::PluralRulesV1Marker, PluralCategory, PluralOperands, PluralRuleType, PluralRules,
-    };
-    use icu_provider::prelude::DataProvider;
+    use icu_plurals::{PluralCategory, PluralOperands, PluralRules};
 
     use crate::{locale::ffi::ICU4XLocale, provider::ffi::ICU4XDataProvider};
 
@@ -20,13 +17,6 @@ pub mod ffi {
         pub success: bool,
     }
 
-    /// FFI version of `PluralRuleType`.
-    /// See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/enum.PluralRuleType.html) for more details.
-    pub enum ICU4XPluralRuleType {
-        Cardinal,
-        Ordinal,
-    }
-
     /// FFI version of `PluralCategory`.
     /// See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/enum.PluralCategory.html) for more details.
     pub enum ICU4XPluralCategory {
@@ -44,43 +34,44 @@ pub mod ffi {
     pub struct ICU4XPluralRules(PluralRules);
 
     impl ICU4XPluralRules {
-        /// FFI version of `PluralRules::try_new()`.
+        /// FFI version of `PluralRules::try_new_cardinal()`.
         /// See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new) for more details.
-        pub fn try_new(
+        pub fn try_new_cardinal(
             locale: &ICU4XLocale,
             provider: &ICU4XDataProvider,
-            ty: ICU4XPluralRuleType,
         ) -> ICU4XCreatePluralRulesResult {
             use icu_provider::serde::AsDeserializingBufferProvider;
             let provider = provider.0.as_deserializing();
-            Self::try_new_impl(locale, &provider, ty)
+            PluralRules::try_new_cardinal(locale.0.as_ref().clone(), &provider)
+                .ok()
+                .map(|r| ICU4XCreatePluralRulesResult {
+                    rules: Some(Box::new(ICU4XPluralRules(r))),
+                    success: true,
+                })
+                .unwrap_or(ICU4XCreatePluralRulesResult {
+                    rules: None,
+                    success: false,
+                })
         }
 
-        fn try_new_impl<D>(
+        /// FFI version of `PluralRules::try_new_ordinal()`.
+        /// See [the Rust docs](https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new) for more details.
+        pub fn try_new_ordinal(
             locale: &ICU4XLocale,
-            provider: &D,
-            ty: ICU4XPluralRuleType,
-        ) -> ICU4XCreatePluralRulesResult
-        where
-            D: DataProvider<PluralRulesV1Marker> + ?Sized,
-        {
-            PluralRules::try_new(
-                locale.0.as_ref().clone(),
-                provider,
-                match ty {
-                    ICU4XPluralRuleType::Cardinal => PluralRuleType::Cardinal,
-                    ICU4XPluralRuleType::Ordinal => PluralRuleType::Ordinal,
-                },
-            )
-            .ok()
-            .map(|r| ICU4XCreatePluralRulesResult {
-                rules: Some(Box::new(ICU4XPluralRules(r))),
-                success: true,
-            })
-            .unwrap_or(ICU4XCreatePluralRulesResult {
-                rules: None,
-                success: false,
-            })
+            provider: &ICU4XDataProvider,
+        ) -> ICU4XCreatePluralRulesResult {
+            use icu_provider::serde::AsDeserializingBufferProvider;
+            let provider = provider.0.as_deserializing();
+            PluralRules::try_new_ordinal(locale.0.as_ref().clone(), &provider)
+                .ok()
+                .map(|r| ICU4XCreatePluralRulesResult {
+                    rules: Some(Box::new(ICU4XPluralRules(r))),
+                    success: true,
+                })
+                .unwrap_or(ICU4XCreatePluralRulesResult {
+                    rules: None,
+                    success: false,
+                })
         }
 
         /// FFI version of `PluralRules::select()`.
diff --git a/ffi/diplomat/wasm/docs/pluralrules_ffi.rst b/ffi/diplomat/wasm/docs/pluralrules_ffi.rst
index 5a61d4cdf73..fd9895f1c67 100644
--- a/ffi/diplomat/wasm/docs/pluralrules_ffi.rst
+++ b/ffi/diplomat/wasm/docs/pluralrules_ffi.rst
@@ -55,17 +55,17 @@
 
         FFI version of ``PluralOperands::from_str()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralOperands.html#method.from_str>`__ for more details.
 
-.. js:class:: ICU4XPluralRuleType
-
-    FFI version of ``PluralRuleType``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/enum.PluralRuleType.html>`__ for more details.
-
 .. js:class:: ICU4XPluralRules
 
     FFI version of ``PluralRules``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html>`__ for more details.
 
-    .. js:staticfunction:: try_new(locale, provider, ty)
+    .. js:staticfunction:: try_new_cardinal(locale, provider)
+
+        FFI version of ``PluralRules::try_new_cardinal()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new>`__ for more details.
+
+    .. js:staticfunction:: try_new_ordinal(locale, provider)
 
-        FFI version of ``PluralRules::try_new()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new>`__ for more details.
+        FFI version of ``PluralRules::try_new_ordinal()``. See `the Rust docs <https://unicode-org.github.io/icu4x-docs/doc/icu_plurals/struct.PluralRules.html#method.try_new>`__ for more details.
 
     .. js:function:: select(op)
 
diff --git a/ffi/diplomat/wasm/lib/api.mjs b/ffi/diplomat/wasm/lib/api.mjs
index de490e63720..8519b0b1621 100644
--- a/ffi/diplomat/wasm/lib/api.mjs
+++ b/ffi/diplomat/wasm/lib/api.mjs
@@ -1364,15 +1364,6 @@ export class ICU4XPluralOperands {
   }
 }
 
-const ICU4XPluralRuleType_js_to_rust = {
-  "Cardinal": 0,
-  "Ordinal": 1,
-};
-const ICU4XPluralRuleType_rust_to_js = {
-  0: "Cardinal",
-  1: "Ordinal",
-};
-
 const ICU4XPluralRules_box_destroy_registry = new FinalizationRegistry(underlying => {
   wasm.ICU4XPluralRules_destroy(underlying);
 });
@@ -1382,10 +1373,32 @@ export class ICU4XPluralRules {
     this.underlying = underlying;
   }
 
-  static try_new(locale, provider, ty) {
+  static try_new_cardinal(locale, provider) {
+    const diplomat_out = (() => {
+      const diplomat_receive_buffer = wasm.diplomat_alloc(5, 4);
+      wasm.ICU4XPluralRules_try_new_cardinal(diplomat_receive_buffer, locale.underlying, provider.underlying);
+      const out = new ICU4XCreatePluralRulesResult(diplomat_receive_buffer);
+      if (out.rules.underlying !== 0) {
+        const out_rules_value = out.rules;
+        ICU4XPluralRules_box_destroy_registry.register(out_rules_value, out_rules_value.underlying);
+        Object.defineProperty(out, "rules", { value: out_rules_value });
+      } else {
+        Object.defineProperty(out, "rules", { value: null });
+      }
+      diplomat_alloc_destroy_registry.register(out, {
+        ptr: out.underlying,
+        size: 5,
+        align: 4,
+      });
+      return out;
+    })();
+    return diplomat_out;
+  }
+
+  static try_new_ordinal(locale, provider) {
     const diplomat_out = (() => {
       const diplomat_receive_buffer = wasm.diplomat_alloc(5, 4);
-      wasm.ICU4XPluralRules_try_new(diplomat_receive_buffer, locale.underlying, provider.underlying, ICU4XPluralRuleType_js_to_rust[ty]);
+      wasm.ICU4XPluralRules_try_new_ordinal(diplomat_receive_buffer, locale.underlying, provider.underlying);
       const out = new ICU4XCreatePluralRulesResult(diplomat_receive_buffer);
       if (out.rules.underlying !== 0) {
         const out_rules_value = out.rules;
diff --git a/ffi/ecma402/src/pluralrules.rs b/ffi/ecma402/src/pluralrules.rs
index baa94cf2cfc..14344b14baf 100644
--- a/ffi/ecma402/src/pluralrules.rs
+++ b/ffi/ecma402/src/pluralrules.rs
@@ -262,7 +262,8 @@ impl PluralRules {
     ) -> Result<Self, PluralRulesError>
     where
         L: ecma402_traits::Locale,
-        P: icu_provider::DataProvider<ipr::provider::PluralRulesV1Marker>,
+        P: icu_provider::ResourceProvider<ipr::provider::OrdinalV1Marker>
+            + icu_provider::ResourceProvider<ipr::provider::CardinalV1Marker>,
         Self: Sized,
     {
         let locale: String = format!("{}", l);
diff --git a/provider/blob/README.md b/provider/blob/README.md
index e6af8e82a6d..d1bff1efb6d 100644
--- a/provider/blob/README.md
+++ b/provider/blob/README.md
@@ -1,6 +1,6 @@
 # icu_provider_blob [![crates.io](https://img.shields.io/crates/v/icu_provider_blob)](https://crates.io/crates/icu_provider_blob)
 
-`icu_provider_blob` contains implementations of the [`ICU4X`] [`DataProvider`] interface
+`icu_provider_blob` contains implementations of the [`ICU4X`] [`BufferProvider`] interface
 that load data from a single blob.
 
 There are two exports:
@@ -30,7 +30,7 @@ let _ = icu_testdata::get_static_provider();
 For more examples, see the specific data providers.
 
 [`ICU4X`]: ../icu/index.html
-[`DataProvider`]: icu_provider::prelude::DataProvider
+[`BufferProvider`]: icu_provider::BufferProvider
 [`icu4x-datagen`]: https://github.com/unicode-org/icu4x/tree/main/tools/datagen#readme
 
 ## More Information
diff --git a/provider/blob/src/blob_data_provider.rs b/provider/blob/src/blob_data_provider.rs
index 98c80214407..f9c3e0d93eb 100644
--- a/provider/blob/src/blob_data_provider.rs
+++ b/provider/blob/src/blob_data_provider.rs
@@ -46,12 +46,10 @@ use zerovec::map2d::{KeyError, ZeroMap2dBorrowed};
 ///     .expect("Deserialization should succeed");
 ///
 /// // Check that it works:
-/// let response: DataPayload<HelloWorldV1Marker> = provider.load_payload(
-///     &DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: langid!("la").into(),
-///         }
+/// let response: DataPayload<HelloWorldV1Marker> = provider
+///     .load_resource(&DataRequest {
+///         options: langid!("la").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect("Data should be valid")
 ///     .take_payload()
@@ -82,28 +80,40 @@ impl BlobDataProvider {
 
     /// Gets the buffer for the given DataRequest out of the BlobSchema and returns it yoked
     /// to the buffer backing the BlobSchema.
-    fn get_file(&self, req: &DataRequest) -> Result<Yoke<&'static [u8], Rc<[u8]>>, DataError> {
+    fn get_file(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<Yoke<&'static [u8], Rc<[u8]>>, DataError> {
         self.data
-            .try_project_cloned_with_capture::<&'static [u8], &DataRequest, DataError>(
-                req,
-                |zm, req, _| {
-                    zm.get(
-                        &req.resource_path.key.get_hash(),
-                        &req.resource_path.options.writeable_to_string(),
-                    )
+            .try_project_cloned_with_capture((key, req), |zm, (key, req), _| {
+                zm.get(&key.get_hash(), &req.options.writeable_to_string())
                     .map_err(|e| {
                         match e {
                             KeyError::K0 => DataErrorKind::MissingResourceKey,
                             KeyError::K1 => DataErrorKind::MissingResourceOptions,
                         }
-                        .with_req(req)
+                        .with_req(key, req)
                     })
-                },
-            )
+            })
     }
 }
 
-impl<M> DataProvider<M> for BlobDataProvider
+impl<M> ResourceProvider<M> for BlobDataProvider
+where
+    M: ResourceMarker,
+    // Actual bound:
+    //     for<'de> <M::Yokeable as Yokeable<'de>>::Output: serde::de::Deserialize<'de>,
+    // Necessary workaround bound (see `yoke::trait_hack` docs):
+    for<'de> YokeTraitHack<<M::Yokeable as yoke::Yokeable<'de>>::Output>:
+        serde::de::Deserialize<'de>,
+{
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+        self.as_deserializing().load_resource(req)
+    }
+}
+
+impl<M> DynProvider<M> for BlobDataProvider
 where
     M: DataMarker,
     // Actual bound:
@@ -112,14 +122,22 @@ where
     for<'de> YokeTraitHack<<M::Yokeable as yoke::Yokeable<'de>>::Output>:
         serde::de::Deserialize<'de>,
 {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
-        self.as_deserializing().load_payload(req)
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
+        self.as_deserializing().load_payload(key, req)
     }
 }
 
 impl BufferProvider for BlobDataProvider {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
-        let yoked_buffer = self.get_file(req)?;
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        let yoked_buffer = self.get_file(key, req)?;
         let mut metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
         metadata.buffer_format = Some(BufferFormat::Postcard07);
diff --git a/provider/blob/src/export/blob_exporter.rs b/provider/blob/src/export/blob_exporter.rs
index 293a7476b58..d9b263e5de8 100644
--- a/provider/blob/src/export/blob_exporter.rs
+++ b/provider/blob/src/export/blob_exporter.rs
@@ -38,18 +38,19 @@ impl Drop for BlobExporter<'_> {
 impl DataExporter<SerializeMarker> for BlobExporter<'_> {
     fn put_payload(
         &mut self,
+        key: ResourceKey,
         req: DataRequest,
         payload: DataPayload<SerializeMarker>,
     ) -> Result<(), DataError> {
-        log::trace!("Adding: {}", req.resource_path);
+        log::trace!("Adding: {} {}", key, req);
         let mut serializer = postcard::Serializer {
             output: postcard::flavors::AllocVec(Vec::new()),
         };
         payload.serialize(&mut <dyn erased_serde::Serializer>::erase(&mut serializer))?;
         self.resources.insert(
             (
-                req.resource_path.key.get_hash(),
-                req.resource_path.options.writeable_to_string().into_owned(),
+                key.get_hash(),
+                req.options.writeable_to_string().into_owned(),
             ),
             serializer.output.0,
         );
diff --git a/provider/blob/src/lib.rs b/provider/blob/src/lib.rs
index 17753234636..000626a3d93 100644
--- a/provider/blob/src/lib.rs
+++ b/provider/blob/src/lib.rs
@@ -2,7 +2,7 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-//! `icu_provider_blob` contains implementations of the [`ICU4X`] [`DataProvider`] interface
+//! `icu_provider_blob` contains implementations of the [`ICU4X`] [`BufferProvider`] interface
 //! that load data from a single blob.
 //!
 //! There are two exports:
@@ -32,7 +32,7 @@
 //! For more examples, see the specific data providers.
 //!
 //! [`ICU4X`]: ../icu/index.html
-//! [`DataProvider`]: icu_provider::prelude::DataProvider
+//! [`BufferProvider`]: icu_provider::BufferProvider
 //! [`icu4x-datagen`]: https://github.com/unicode-org/icu4x/tree/main/tools/datagen#readme
 
 #![cfg_attr(not(any(test, feature = "std")), no_std)]
diff --git a/provider/blob/src/static_data_provider.rs b/provider/blob/src/static_data_provider.rs
index f5ace2083ba..25a5fdaa209 100644
--- a/provider/blob/src/static_data_provider.rs
+++ b/provider/blob/src/static_data_provider.rs
@@ -36,17 +36,14 @@ use zerovec::map2d::{KeyError, ZeroMap2dBorrowed};
 /// let provider = StaticDataProvider::new_from_static_blob(&HELLO_WORLD_BLOB)
 ///     .expect("Deserialization should succeed");
 ///
-/// let response: DataPayload<HelloWorldV1Marker> = provider.load_payload(
-///     &DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: langid!("la").into(),
-///         }
-///     }
-/// )
-/// .expect("Data should be valid")
-/// .take_payload()
-/// .expect("Data should be present");
+/// let response: DataPayload<HelloWorldV1Marker> = provider
+///     .load_resource(&DataRequest {
+///         options: langid!("la").into(),
+///         metadata: Default::default(),
+///     })
+///     .expect("Data should be valid")
+///     .take_payload()
+///     .expect("Data should be present");
 ///
 /// assert_eq!(response.get().message, "Ave, munde");
 /// ```
@@ -83,13 +80,11 @@ impl StaticDataProvider {
     ///
     /// let stub_provider = StaticDataProvider::new_empty();
     ///
-    /// DataProvider::<HelloWorldV1Marker>::load_payload(
+    /// ResourceProvider::<HelloWorldV1Marker>::load_resource(
     ///     &stub_provider,
     ///     &DataRequest {
-    ///         resource_path: ResourcePath {
-    ///             key: key::HELLO_WORLD_V1,
-    ///             options: langid!("la").into(),
-    ///         }
+    ///         options: langid!("la").into(),
+    ///         metadata: Default::default(),
     ///     }
     /// )
     /// .expect_err("Stub provider returns no data");
@@ -100,23 +95,34 @@ impl StaticDataProvider {
         }
     }
 
-    fn get_file(&self, req: &DataRequest) -> Result<&'static [u8], DataError> {
+    fn get_file(&self, key: ResourceKey, req: &DataRequest) -> Result<&'static [u8], DataError> {
         self.data
-            .get(
-                &req.resource_path.key.get_hash(),
-                &req.resource_path.options.writeable_to_string(),
-            )
+            .get(&key.get_hash(), &req.options.writeable_to_string())
             .map_err(|e| {
                 match e {
                     KeyError::K0 => DataErrorKind::MissingResourceKey,
                     KeyError::K1 => DataErrorKind::MissingResourceOptions,
                 }
-                .with_req(req)
+                .with_req(key, req)
             })
     }
 }
 
-impl<M> DataProvider<M> for StaticDataProvider
+impl<M> ResourceProvider<M> for StaticDataProvider
+where
+    M: ResourceMarker,
+    // Actual bound:
+    //     for<'de> <M::Yokeable as Yokeable<'de>>::Output: serde::de::Deserialize<'de>,
+    // Necessary workaround bound (see `yoke::trait_hack` docs):
+    for<'de> YokeTraitHack<<M::Yokeable as yoke::Yokeable<'de>>::Output>:
+        serde::de::Deserialize<'de>,
+{
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+        self.as_deserializing().load_resource(req)
+    }
+}
+
+impl<M> DynProvider<M> for StaticDataProvider
 where
     M: DataMarker,
     // Actual bound:
@@ -125,14 +131,22 @@ where
     for<'de> YokeTraitHack<<M::Yokeable as yoke::Yokeable<'de>>::Output>:
         serde::de::Deserialize<'de>,
 {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
-        self.as_deserializing().load_payload(req)
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
+        self.as_deserializing().load_payload(key, req)
     }
 }
 
 impl BufferProvider for StaticDataProvider {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
-        let static_buffer = self.get_file(req)?;
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        let static_buffer = self.get_file(key, req)?;
         let mut metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
         metadata.buffer_format = Some(BufferFormat::Postcard07);
diff --git a/provider/cldr/README.md b/provider/cldr/README.md
index eec1f072972..8fa88fa895f 100644
--- a/provider/cldr/README.md
+++ b/provider/cldr/README.md
@@ -1,6 +1,6 @@
 # icu_provider_cldr [![crates.io](https://img.shields.io/crates/v/icu_provider_cldr)](https://crates.io/crates/icu_provider_cldr)
 
-`icu_provider_cldr` contains implementations of the [`ICU4X`] [`DataProvider`] interface
+`icu_provider_cldr` contains implementations of the [`ICU4X`] [data provider] interface
 based on the JSON files shipped by CLDR. Create a [`CldrPaths`] and then pass it into
 [`CldrJsonDataProvider`].
 
@@ -14,7 +14,7 @@ This crate contains two implementations of [`CldrPaths`]:
 It is much more efficient if you use [`FsDataProvider`] instead.
 
 [`ICU4X`]: ../icu/index.html
-[`DataProvider`]: icu_provider::prelude::DataProvider
+[data provider]: icu_provider
 [`FsDataProvider`]: ../icu_provider_fs/struct.FsDataProvider.html
 [`CldrJsonDataProvider`]: transform::CldrJsonDataProvider
 
diff --git a/provider/cldr/src/download/cldr_allinone.rs b/provider/cldr/src/download/cldr_allinone.rs
index 68608d34628..ad718898b3d 100644
--- a/provider/cldr/src/download/cldr_allinone.rs
+++ b/provider/cldr/src/download/cldr_allinone.rs
@@ -41,15 +41,13 @@ use std::path::PathBuf;
 ///         .expect("The data should be well-formed after downloading");
 ///
 ///     let data: DataPayload<icu_plurals::provider::PluralRulesV1Marker> = data_provider
-///         .load_payload(&DataRequest {
-///             resource_path: ResourcePath {
-///                 key: icu_plurals::provider::key::ORDINAL_V1,
-///                 options: ResourceOptions {
-///                     langid: Some(langid!("uk")),
-///                     variant: None,
-///                 },
-///             },
-///         })
+///         .load_payload(
+///             icu_plurals::provider::OrdinalV1Marker::KEY,
+///             &DataRequest {
+///                 options: langid!("uk").into(),
+///                 metadata: Default::default(),
+///             }
+///         )
 ///         .unwrap()
 ///         .take_payload()
 ///         .unwrap();
diff --git a/provider/cldr/src/lib.rs b/provider/cldr/src/lib.rs
index 07c71c766d8..678e3a6a0c7 100644
--- a/provider/cldr/src/lib.rs
+++ b/provider/cldr/src/lib.rs
@@ -2,7 +2,7 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-//! `icu_provider_cldr` contains implementations of the [`ICU4X`] [`DataProvider`] interface
+//! `icu_provider_cldr` contains implementations of the [`ICU4X`] [data provider] interface
 //! based on the JSON files shipped by CLDR. Create a [`CldrPaths`] and then pass it into
 //! [`CldrJsonDataProvider`].
 //!
@@ -16,7 +16,7 @@
 //! It is much more efficient if you use [`FsDataProvider`] instead.
 //!
 //! [`ICU4X`]: ../icu/index.html
-//! [`DataProvider`]: icu_provider::prelude::DataProvider
+//! [data provider]: icu_provider
 //! [`FsDataProvider`]: ../icu_provider_fs/struct.FsDataProvider.html
 //! [`CldrJsonDataProvider`]: transform::CldrJsonDataProvider
 
diff --git a/provider/cldr/src/support.rs b/provider/cldr/src/support.rs
index 9c8e61bbc27..8d2173c0219 100644
--- a/provider/cldr/src/support.rs
+++ b/provider/cldr/src/support.rs
@@ -72,7 +72,7 @@ impl<T> Default for LazyCldrProvider<T> {
 /// A lazy-initialized CLDR JSON data provider.
 impl<'b, T> LazyCldrProvider<T>
 where
-    T: DataProvider<SerializeMarker>
+    T: DynProvider<SerializeMarker>
         + IterableProvider
         + KeyedDataProvider
         + TryFrom<&'b dyn CldrPaths, Error = crate::error::Error>,
@@ -80,14 +80,15 @@ where
     /// Call [`DataProvider::load_payload()`], initializing `T` if necessary.
     pub fn try_load_serde(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
         cldr_paths: &'b dyn CldrPaths,
     ) -> Result<Option<DataResponse<SerializeMarker>>, DataError> {
-        if T::supports_key(&req.resource_path.key).is_err() {
+        if T::supports_key(&key).is_err() {
             return Ok(None);
         }
         if let Some(data_provider) = self.src.read()?.as_ref() {
-            return DataProvider::load_payload(data_provider, req).map(Some);
+            return DynProvider::load_payload(data_provider, key, req).map(Some);
         }
         let mut src = self.src.write()?;
         if src.is_none() {
@@ -96,7 +97,7 @@ where
         let data_provider = src
             .as_ref()
             .expect("The RwLock must be populated at this point.");
-        DataProvider::load_payload(data_provider, req).map(Some)
+        DynProvider::load_payload(data_provider, key, req).map(Some)
     }
 
     /// Call [`IterableProvider::supported_options_for_key()`], initializing `T` if necessary.
diff --git a/provider/cldr/src/transform/calendar/japanese.rs b/provider/cldr/src/transform/calendar/japanese.rs
index 6c1a7a297db..04fc54ef4d8 100644
--- a/provider/cldr/src/transform/calendar/japanese.rs
+++ b/provider/cldr/src/transform/calendar/japanese.rs
@@ -204,14 +204,15 @@ impl KeyedDataProvider for JapaneseErasProvider {
     }
 }
 
-impl DataProvider<JapaneseErasV1Marker> for JapaneseErasProvider {
-    fn load_payload(
+impl ResourceProvider<JapaneseErasV1Marker> for JapaneseErasProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<JapaneseErasV1Marker>, DataError> {
-        if req.resource_path.options.langid.is_some() || req.resource_path.options.variant.is_some()
-        {
-            return Err(DataErrorKind::ExtraneousResourceOptions.with_req(req));
+        if req.options.langid.is_some() || req.options.variant.is_some() {
+            return Err(
+                DataErrorKind::ExtraneousResourceOptions.with_req(JapaneseErasV1Marker::KEY, req)
+            );
         }
         Ok(DataResponse {
             metadata: DataResponseMetadata::default(),
@@ -223,9 +224,7 @@ impl DataProvider<JapaneseErasV1Marker> for JapaneseErasProvider {
     }
 }
 
-icu_provider::impl_dyn_provider!(JapaneseErasProvider, {
-    _ => JapaneseErasV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(JapaneseErasProvider, [JapaneseErasV1Marker,], SERDE_SE);
 
 impl IterableProvider for JapaneseErasProvider {
     fn supported_options_for_key(
diff --git a/provider/cldr/src/transform/datetime/common.rs b/provider/cldr/src/transform/datetime/common.rs
index 9fcd49b5398..5f0979ddcf8 100644
--- a/provider/cldr/src/transform/datetime/common.rs
+++ b/provider/cldr/src/transform/datetime/common.rs
@@ -57,24 +57,25 @@ impl TryFrom<&dyn CldrPaths> for CommonDateProvider {
 }
 
 impl CommonDateProvider {
-    pub fn dates_for<'a>(
+    pub fn dates_for<'a, M: ResourceMarker>(
         &'a self,
         req: &DataRequest,
     ) -> Result<&'a cldr_serde::ca::Dates, DataError> {
-        let langid = req.try_langid()?;
+        let langid = req
+            .get_langid()
+            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(M::KEY, req))?;
         let variant = req
-            .resource_path
             .options
             .variant
             .as_ref()
-            .ok_or_else(|| DataErrorKind::NeedsVariant.with_req(req))?;
+            .ok_or_else(|| DataErrorKind::NeedsVariant.with_req(M::KEY, req))?;
         let map = self
             .data
             .get(&**variant)
-            .ok_or_else(|| DataErrorKind::MissingVariant.with_req(req))?;
+            .ok_or_else(|| DataErrorKind::MissingVariant.with_req(M::KEY, req))?;
         match map.get(langid) {
             Some(date) => Ok(date),
-            None => Err(DataErrorKind::MissingLocale.with_req(req)),
+            None => Err(DataErrorKind::MissingLocale.with_req(M::KEY, req)),
         }
     }
 }
diff --git a/provider/cldr/src/transform/datetime/patterns.rs b/provider/cldr/src/transform/datetime/patterns.rs
index 786a772d5a9..ceca39f618a 100644
--- a/provider/cldr/src/transform/datetime/patterns.rs
+++ b/provider/cldr/src/transform/datetime/patterns.rs
@@ -38,13 +38,12 @@ impl KeyedDataProvider for DatePatternsProvider {
     }
 }
 
-impl DataProvider<calendar::DatePatternsV1Marker> for DatePatternsProvider {
-    fn load_payload(
+impl ResourceProvider<calendar::DatePatternsV1Marker> for DatePatternsProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<calendar::DatePatternsV1Marker>, DataError> {
-        DatePatternsProvider::supports_key(&req.resource_path.key)?;
-        let dates = self.0.dates_for(req)?;
+        let dates = self.0.dates_for::<calendar::DatePatternsV1Marker>(req)?;
         let metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
         Ok(DataResponse {
@@ -56,9 +55,11 @@ impl DataProvider<calendar::DatePatternsV1Marker> for DatePatternsProvider {
     }
 }
 
-icu_provider::impl_dyn_provider!(DatePatternsProvider, {
-    _ => calendar::DatePatternsV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(
+    DatePatternsProvider,
+    [calendar::DatePatternsV1Marker,],
+    SERDE_SE
+);
 
 impl IterableProvider for DatePatternsProvider {
     #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
@@ -275,14 +276,12 @@ fn test_basic() {
         .expect("Failed to retrieve provider");
 
     let cs_dates: DataPayload<calendar::DatePatternsV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::DATE_PATTERNS_V1,
-                options: ResourceOptions {
-                    variant: Some("gregory".into()),
-                    langid: Some(langid!("cs")),
-                },
+        .load_resource(&DataRequest {
+            options: ResourceOptions {
+                variant: Some("gregory".into()),
+                langid: Some(langid!("cs")),
             },
+            metadata: Default::default(),
         })
         .expect("Failed to load payload")
         .take_payload()
@@ -300,14 +299,12 @@ fn test_with_numbering_system() {
         .expect("Failed to retrieve provider");
 
     let cs_dates: DataPayload<calendar::DatePatternsV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::DATE_PATTERNS_V1,
-                options: ResourceOptions {
-                    variant: Some("gregory".into()),
-                    langid: Some(langid!("haw")),
-                },
+        .load_resource(&DataRequest {
+            options: ResourceOptions {
+                variant: Some("gregory".into()),
+                langid: Some(langid!("haw")),
             },
+            metadata: Default::default(),
         })
         .expect("Failed to load payload")
         .take_payload()
diff --git a/provider/cldr/src/transform/datetime/skeletons.rs b/provider/cldr/src/transform/datetime/skeletons.rs
index ab2a186e8ab..95b137c0a09 100644
--- a/provider/cldr/src/transform/datetime/skeletons.rs
+++ b/provider/cldr/src/transform/datetime/skeletons.rs
@@ -37,13 +37,14 @@ impl KeyedDataProvider for DateSkeletonPatternsProvider {
     }
 }
 
-impl DataProvider<calendar::DateSkeletonPatternsV1Marker> for DateSkeletonPatternsProvider {
-    fn load_payload(
+impl ResourceProvider<calendar::DateSkeletonPatternsV1Marker> for DateSkeletonPatternsProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<calendar::DateSkeletonPatternsV1Marker>, DataError> {
-        DateSkeletonPatternsProvider::supports_key(&req.resource_path.key)?;
-        let dates = self.0.dates_for(req)?;
+        let dates = self
+            .0
+            .dates_for::<calendar::DateSkeletonPatternsV1Marker>(req)?;
         let metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
         Ok(DataResponse {
@@ -55,9 +56,11 @@ impl DataProvider<calendar::DateSkeletonPatternsV1Marker> for DateSkeletonPatter
     }
 }
 
-icu_provider::impl_dyn_provider!(DateSkeletonPatternsProvider, {
-    _ => calendar::DateSkeletonPatternsV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(
+    DateSkeletonPatternsProvider,
+    [calendar::DateSkeletonPatternsV1Marker,],
+    SERDE_SE
+);
 
 impl IterableProvider for DateSkeletonPatternsProvider {
     #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
@@ -159,14 +162,12 @@ fn test_datetime_skeletons() {
         .expect("Failed to retrieve provider");
 
     let skeletons: DataPayload<calendar::DateSkeletonPatternsV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::DATE_SKELETON_PATTERNS_V1,
-                options: ResourceOptions {
-                    variant: Some("gregory".into()),
-                    langid: Some(langid!("fil")),
-                },
+        .load_resource(&DataRequest {
+            options: ResourceOptions {
+                variant: Some("gregory".into()),
+                langid: Some(langid!("fil")),
             },
+            metadata: Default::default(),
         })
         .expect("Failed to load payload")
         .take_payload()
diff --git a/provider/cldr/src/transform/datetime/symbols.rs b/provider/cldr/src/transform/datetime/symbols.rs
index ee8675dc6d1..0c86ebd3205 100644
--- a/provider/cldr/src/transform/datetime/symbols.rs
+++ b/provider/cldr/src/transform/datetime/symbols.rs
@@ -39,21 +39,17 @@ impl KeyedDataProvider for DateSymbolsProvider {
     }
 }
 
-impl DataProvider<calendar::DateSymbolsV1Marker> for DateSymbolsProvider {
-    fn load_payload(
+impl ResourceProvider<calendar::DateSymbolsV1Marker> for DateSymbolsProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<calendar::DateSymbolsV1Marker>, DataError> {
-        DateSymbolsProvider::supports_key(&req.resource_path.key)?;
-        let dates = self.0.dates_for(req)?;
+        let dates = self.0.dates_for::<calendar::DateSymbolsV1Marker>(req)?;
         let metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
-        let calendar = req
-            .resource_path
-            .options
-            .variant
-            .as_ref()
-            .ok_or_else(|| DataErrorKind::NeedsVariant.with_req(req))?;
+        let calendar = req.options.variant.as_ref().ok_or_else(|| {
+            DataErrorKind::NeedsVariant.with_req(calendar::DateSymbolsV1Marker::KEY, req)
+        })?;
         Ok(DataResponse {
             metadata,
             payload: Some(DataPayload::from_owned(convert_dates(dates, calendar))),
@@ -61,9 +57,11 @@ impl DataProvider<calendar::DateSymbolsV1Marker> for DateSymbolsProvider {
     }
 }
 
-icu_provider::impl_dyn_provider!(DateSymbolsProvider, {
-    _ => calendar::DateSymbolsV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(
+    DateSymbolsProvider,
+    [calendar::DateSymbolsV1Marker,],
+    SERDE_SE
+);
 
 impl IterableProvider for DateSymbolsProvider {
     #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
@@ -246,14 +244,12 @@ fn test_basic() {
     let provider = DateSymbolsProvider::try_from(&cldr_paths as &dyn CldrPaths).unwrap();
 
     let cs_dates: DataPayload<calendar::DateSymbolsV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::DATE_SYMBOLS_V1,
-                options: ResourceOptions {
-                    variant: Some("gregory".into()),
-                    langid: Some(langid!("cs")),
-                },
+        .load_resource(&DataRequest {
+            options: ResourceOptions {
+                variant: Some("gregory".into()),
+                langid: Some(langid!("cs")),
             },
+            metadata: Default::default(),
         })
         .unwrap()
         .take_payload()
@@ -275,14 +271,12 @@ fn unalias_contexts() {
     let provider = DateSymbolsProvider::try_from(&cldr_paths as &dyn CldrPaths).unwrap();
 
     let cs_dates: DataPayload<calendar::DateSymbolsV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::DATE_SYMBOLS_V1,
-                options: ResourceOptions {
-                    variant: Some("gregory".into()),
-                    langid: Some(langid!("cs")),
-                },
+        .load_resource(&DataRequest {
+            options: ResourceOptions {
+                variant: Some("gregory".into()),
+                langid: Some(langid!("cs")),
             },
+            metadata: Default::default(),
         })
         .unwrap()
         .take_payload()
diff --git a/provider/cldr/src/transform/decimal/mod.rs b/provider/cldr/src/transform/decimal/mod.rs
index 15fefa4cf2e..8a398fe802a 100644
--- a/provider/cldr/src/transform/decimal/mod.rs
+++ b/provider/cldr/src/transform/decimal/mod.rs
@@ -98,17 +98,21 @@ impl NumbersProvider {
     }
 }
 
-impl DataProvider<DecimalSymbolsV1Marker> for NumbersProvider {
-    fn load_payload(
+impl ResourceProvider<DecimalSymbolsV1Marker> for NumbersProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<DecimalSymbolsV1Marker>, DataError> {
-        Self::supports_key(&req.resource_path.key)?;
-        let langid = req.try_langid()?;
-        let numbers = match self.cldr_numbers_data.get(langid) {
-            Some(v) => &v.numbers,
-            None => return Err(DataErrorKind::MissingLocale.with_req(req)),
-        };
+        let langid = req
+            .get_langid()
+            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(DecimalSymbolsV1Marker::KEY, req))?;
+        let numbers = self
+            .cldr_numbers_data
+            .get(langid)
+            .map(|v| &v.numbers)
+            .ok_or_else(|| {
+                DataErrorKind::MissingLocale.with_req(DecimalSymbolsV1Marker::KEY, req)
+            })?;
         let nsname = numbers.default_numbering_system;
 
         let mut result = DecimalSymbolsV1::try_from(numbers)
@@ -131,9 +135,7 @@ impl DataProvider<DecimalSymbolsV1Marker> for NumbersProvider {
     }
 }
 
-icu_provider::impl_dyn_provider!(NumbersProvider, {
-    _ => DecimalSymbolsV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(NumbersProvider, [DecimalSymbolsV1Marker,], SERDE_SE);
 
 impl IterableProvider for NumbersProvider {
     #[allow(clippy::needless_collect)] // https://github.com/rust-lang/rust-clippy/issues/7526
@@ -197,14 +199,9 @@ fn test_basic() {
     let provider = NumbersProvider::try_from(&cldr_paths as &dyn CldrPaths).unwrap();
 
     let ar_decimal: DataPayload<DecimalSymbolsV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::SYMBOLS_V1,
-                options: ResourceOptions {
-                    variant: None,
-                    langid: Some(langid!("ar-EG")),
-                },
-            },
+        .load_resource(&DataRequest {
+            options: langid!("ar-EG").into(),
+            metadata: Default::default(),
         })
         .unwrap()
         .take_payload()
diff --git a/provider/cldr/src/transform/list/mod.rs b/provider/cldr/src/transform/list/mod.rs
index 18997d93a91..f60a8957061 100644
--- a/provider/cldr/src/transform/list/mod.rs
+++ b/provider/cldr/src/transform/list/mod.rs
@@ -54,28 +54,31 @@ impl KeyedDataProvider for ListProvider {
     }
 }
 
-impl DataProvider<ListFormatterPatternsV1Marker> for ListProvider {
+impl DynProvider<ListFormatterPatternsV1Marker> for ListProvider {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<ListFormatterPatternsV1Marker>, DataError> {
-        Self::supports_key(&req.resource_path.key)?;
-        let langid = req.try_langid()?;
+        Self::supports_key(&key)?;
+        let langid = req
+            .get_langid()
+            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(key, req))?;
         let data = match self.data.get(langid) {
             Some(v) => &v.list_patterns,
-            None => return Err(DataErrorKind::MissingLocale.with_req(req)),
+            None => return Err(DataErrorKind::MissingLocale.with_req(key, req)),
         };
 
-        let mut patterns = match req.resource_path.key {
+        let mut patterns = match key {
             key::LIST_FORMAT_AND_V1 => parse_and_patterns(data),
             key::LIST_FORMAT_OR_V1 => parse_or_patterns(data),
             key::LIST_FORMAT_UNIT_V1 => parse_unit_patterns(data),
             _ => unreachable!(),
         }
-        .map_err(|e| e.with_req(req))?;
+        .map_err(|e| e.with_req(key, req))?;
 
         if langid.language == langid!("es").language {
-            match req.resource_path.key {
+            match key {
                 // Replace " y " with " e " before /i/ sounds.
                 // https://unicode.org/reports/tr35/tr35-general.html#:~:text=important.%20For%20example%3A-,Spanish,AND,-Use%20%E2%80%98e%E2%80%99%20instead
                 key::LIST_FORMAT_AND_V1 | key::LIST_FORMAT_UNIT_V1 => patterns
diff --git a/provider/cldr/src/transform/locale_canonicalizer/aliases.rs b/provider/cldr/src/transform/locale_canonicalizer/aliases.rs
index 4516e836476..e3b5a01ed66 100644
--- a/provider/cldr/src/transform/locale_canonicalizer/aliases.rs
+++ b/provider/cldr/src/transform/locale_canonicalizer/aliases.rs
@@ -52,10 +52,9 @@ impl KeyedDataProvider for AliasesProvider {
     }
 }
 
-impl DataProvider<AliasesV1Marker> for AliasesProvider {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<AliasesV1Marker>, DataError> {
-        AliasesProvider::supports_key(&req.resource_path.key)?;
-        let langid = &req.resource_path.options.langid;
+impl ResourceProvider<AliasesV1Marker> for AliasesProvider {
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<AliasesV1Marker>, DataError> {
+        let langid = &req.options.langid;
 
         // We treat searching for und as a request for all data. Other requests
         // are not currently supported.
@@ -67,14 +66,12 @@ impl DataProvider<AliasesV1Marker> for AliasesProvider {
                 payload: Some(DataPayload::from_owned(AliasesV1::from(&self.data))),
             })
         } else {
-            Err(DataErrorKind::ExtraneousResourceOptions.with_req(req))
+            Err(DataErrorKind::ExtraneousResourceOptions.with_req(AliasesV1Marker::KEY, req))
         }
     }
 }
 
-icu_provider::impl_dyn_provider!(AliasesProvider, {
-    _ => AliasesV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(AliasesProvider, [AliasesV1Marker,], SERDE_SE);
 
 impl IterableProvider for AliasesProvider {
     fn supported_options_for_key(
@@ -309,7 +306,7 @@ fn test_basic() {
     let cldr_paths = crate::cldr_paths::for_test();
     let provider = AliasesProvider::try_from(&cldr_paths as &dyn CldrPaths).unwrap();
     let data: DataPayload<AliasesV1Marker> = provider
-        .load_payload(&DataRequest::from(key::ALIASES_V1))
+        .load_resource(&DataRequest::default())
         .unwrap()
         .take_payload()
         .unwrap();
diff --git a/provider/cldr/src/transform/locale_canonicalizer/likely_subtags.rs b/provider/cldr/src/transform/locale_canonicalizer/likely_subtags.rs
index 8abe577015f..4475365aec3 100644
--- a/provider/cldr/src/transform/locale_canonicalizer/likely_subtags.rs
+++ b/provider/cldr/src/transform/locale_canonicalizer/likely_subtags.rs
@@ -44,13 +44,12 @@ impl KeyedDataProvider for LikelySubtagsProvider {
     }
 }
 
-impl DataProvider<LikelySubtagsV1Marker> for LikelySubtagsProvider {
-    fn load_payload(
+impl ResourceProvider<LikelySubtagsV1Marker> for LikelySubtagsProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<LikelySubtagsV1Marker>, DataError> {
-        LikelySubtagsProvider::supports_key(&req.resource_path.key)?;
-        let langid = &req.resource_path.options.langid;
+        let langid = &req.options.langid;
 
         // We treat searching for und as a request for all data. Other requests
         // are not currently supported.
@@ -62,14 +61,12 @@ impl DataProvider<LikelySubtagsV1Marker> for LikelySubtagsProvider {
                 payload: Some(DataPayload::from_owned(LikelySubtagsV1::from(&self.data))),
             })
         } else {
-            Err(DataErrorKind::ExtraneousResourceOptions.with_req(req))
+            Err(DataErrorKind::ExtraneousResourceOptions.with_req(LikelySubtagsV1Marker::KEY, req))
         }
     }
 }
 
-icu_provider::impl_dyn_provider!(LikelySubtagsProvider, {
-    _ => LikelySubtagsV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(LikelySubtagsProvider, [LikelySubtagsV1Marker,], SERDE_SE);
 
 impl IterableProvider for LikelySubtagsProvider {
     fn supported_options_for_key(
@@ -158,7 +155,7 @@ fn test_basic() {
     let cldr_paths = crate::cldr_paths::for_test();
     let provider = LikelySubtagsProvider::try_from(&cldr_paths as &dyn CldrPaths).unwrap();
     let result: DataPayload<LikelySubtagsV1Marker> = provider
-        .load_payload(&DataRequest::from(key::LIKELY_SUBTAGS_V1))
+        .load_resource(&Default::default())
         .unwrap()
         .take_payload()
         .unwrap();
diff --git a/provider/cldr/src/transform/mod.rs b/provider/cldr/src/transform/mod.rs
index 708cba61b65..ed7bdcf63b4 100644
--- a/provider/cldr/src/transform/mod.rs
+++ b/provider/cldr/src/transform/mod.rs
@@ -88,40 +88,56 @@ impl<'a> CldrJsonDataProvider<'a> {
     }
 }
 
-impl<'a> DataProvider<SerializeMarker> for CldrJsonDataProvider<'a> {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<SerializeMarker>, DataError> {
-        if let Some(result) = self.aliases.try_load_serde(req, self.cldr_paths)? {
+impl<'a> DynProvider<SerializeMarker> for CldrJsonDataProvider<'a> {
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<SerializeMarker>, DataError> {
+        if let Some(result) = self.aliases.try_load_serde(key, req, self.cldr_paths)? {
             return Ok(result);
         }
-        if let Some(result) = self.date_symbols.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self
+            .date_symbols
+            .try_load_serde(key, req, self.cldr_paths)?
+        {
             return Ok(result);
         }
-        if let Some(result) = self.date_skeletons.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self
+            .date_skeletons
+            .try_load_serde(key, req, self.cldr_paths)?
+        {
             return Ok(result);
         }
-        if let Some(result) = self.date_patterns.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self
+            .date_patterns
+            .try_load_serde(key, req, self.cldr_paths)?
+        {
             return Ok(result);
         }
-        if let Some(result) = self.japanese.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self.japanese.try_load_serde(key, req, self.cldr_paths)? {
             return Ok(result);
         }
-        if let Some(result) = self.likelysubtags.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self
+            .likelysubtags
+            .try_load_serde(key, req, self.cldr_paths)?
+        {
             return Ok(result);
         }
-        if let Some(result) = self.numbers.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self.numbers.try_load_serde(key, req, self.cldr_paths)? {
             return Ok(result);
         }
-        if let Some(result) = self.plurals.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self.plurals.try_load_serde(key, req, self.cldr_paths)? {
             return Ok(result);
         }
-        if let Some(result) = self.time_zones.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self.time_zones.try_load_serde(key, req, self.cldr_paths)? {
             return Ok(result);
         }
         #[cfg(feature = "icu_list")]
-        if let Some(result) = self.list.try_load_serde(req, self.cldr_paths)? {
+        if let Some(result) = self.list.try_load_serde(key, req, self.cldr_paths)? {
             return Ok(result);
         }
-        Err(DataErrorKind::MissingResourceKey.with_req(req))
+        Err(DataErrorKind::MissingResourceKey.with_req(key, req))
     }
 }
 
diff --git a/provider/cldr/src/transform/plurals/mod.rs b/provider/cldr/src/transform/plurals/mod.rs
index 6fccd9a9c3c..cea74ecf357 100644
--- a/provider/cldr/src/transform/plurals/mod.rs
+++ b/provider/cldr/src/transform/plurals/mod.rs
@@ -80,17 +80,20 @@ impl PluralsProvider {
     }
 }
 
-impl DataProvider<PluralRulesV1Marker> for PluralsProvider {
+impl DynProvider<PluralRulesV1Marker> for PluralsProvider {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<PluralRulesV1Marker>, DataError> {
-        let cldr_rules = self.get_rules_for(&req.resource_path.key)?;
+        let cldr_rules = self.get_rules_for(&key)?;
         // TODO: Implement language fallback?
-        let langid = req.try_langid()?;
+        let langid = req
+            .get_langid()
+            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(key, req))?;
         let r = match cldr_rules.0.get(langid) {
             Some(v) => v,
-            None => return Err(DataErrorKind::MissingLocale.with_req(req)),
+            None => return Err(DataErrorKind::MissingLocale.with_req(key, req)),
         };
         let metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
@@ -152,15 +155,13 @@ fn test_basic() {
 
     // Spot-check locale 'cs' since it has some interesting entries
     let cs_rules: DataPayload<PluralRulesV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::CARDINAL_V1,
-                options: ResourceOptions {
-                    variant: None,
-                    langid: Some(langid!("cs")),
-                },
+        .load_payload(
+            CardinalV1Marker::KEY,
+            &DataRequest {
+                options: langid!("cs").into(),
+                metadata: Default::default(),
             },
-        })
+        )
         .unwrap()
         .take_payload()
         .unwrap();
diff --git a/provider/cldr/src/transform/time_zones/mod.rs b/provider/cldr/src/transform/time_zones/mod.rs
index c12e1ecf596..aec0de59f81 100644
--- a/provider/cldr/src/transform/time_zones/mod.rs
+++ b/provider/cldr/src/transform/time_zones/mod.rs
@@ -68,14 +68,17 @@ impl TryFrom<&str> for TimeZonesProvider {
 impl KeyedDataProvider for TimeZonesProvider {
     fn supports_key(resc_key: &ResourceKey) -> Result<(), DataError> {
         // TODO(#442): Clean up KeyedDataProvider
-        match *resc_key {
-            key::TIMEZONE_FORMATS_V1 => Ok(()),
-            key::TIMEZONE_EXEMPLAR_CITIES_V1 => Ok(()),
-            key::TIMEZONE_GENERIC_NAMES_LONG_V1 => Ok(()),
-            key::TIMEZONE_GENERIC_NAMES_SHORT_V1 => Ok(()),
-            key::TIMEZONE_SPECIFIC_NAMES_LONG_V1 => Ok(()),
-            key::TIMEZONE_SPECIFIC_NAMES_SHORT_V1 => Ok(()),
-            _ => Err(DataErrorKind::MissingResourceKey.with_key(*resc_key)),
+        // Note: This is a big if{} instead of match{} due to Rust bug #93470
+        if !(!(*resc_key == key::TIMEZONE_FORMATS_V1)
+            && !(*resc_key == key::TIMEZONE_EXEMPLAR_CITIES_V1)
+            && !(*resc_key == key::TIMEZONE_GENERIC_NAMES_LONG_V1)
+            && !(*resc_key == key::TIMEZONE_GENERIC_NAMES_SHORT_V1)
+            && !(*resc_key == key::TIMEZONE_SPECIFIC_NAMES_LONG_V1)
+            && !(*resc_key == key::TIMEZONE_SPECIFIC_NAMES_SHORT_V1))
+        {
+            Ok(())
+        } else {
+            Err(DataErrorKind::MissingResourceKey.with_key(*resc_key))
         }
     }
 }
@@ -100,13 +103,14 @@ impl IterableProvider for TimeZonesProvider {
 
 macro_rules! impl_data_provider {
     ($id:ident, $marker:ident) => {
-        impl DataProvider<$marker> for TimeZonesProvider {
-            fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<$marker>, DataError> {
-                TimeZonesProvider::supports_key(&req.resource_path.key)?;
-                let langid = req.try_langid()?;
+        impl ResourceProvider<$marker> for TimeZonesProvider {
+            fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<$marker>, DataError> {
+                let langid = req
+                    .get_langid()
+                    .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(<$marker>::KEY, req))?;
                 let time_zones = match self.data.get(&langid) {
                     Some(v) => &v.dates.time_zone_names,
-                    None => return Err(DataErrorKind::MissingLocale.with_req(req)),
+                    None => return Err(DataErrorKind::MissingLocale.with_req(<$marker>::KEY, req)),
                 };
                 let metadata = DataResponseMetadata::default();
                 // TODO(#1109): Set metadata.data_langid correctly.
@@ -119,14 +123,18 @@ macro_rules! impl_data_provider {
     };
 }
 
-icu_provider::impl_dyn_provider!(TimeZonesProvider, {
-    key::TIMEZONE_FORMATS_V1 => TimeZoneFormatsV1Marker,
-    key::TIMEZONE_EXEMPLAR_CITIES_V1 => ExemplarCitiesV1Marker,
-    key::TIMEZONE_GENERIC_NAMES_LONG_V1 => MetaZoneGenericNamesLongV1Marker,
-    key::TIMEZONE_GENERIC_NAMES_SHORT_V1 => MetaZoneGenericNamesShortV1Marker,
-    key::TIMEZONE_SPECIFIC_NAMES_LONG_V1 => MetaZoneSpecificNamesLongV1Marker,
-    key::TIMEZONE_SPECIFIC_NAMES_SHORT_V1 => MetaZoneSpecificNamesShortV1Marker,
-}, SERDE_SE);
+icu_provider::impl_dyn_provider!(
+    TimeZonesProvider,
+    [
+        TimeZoneFormatsV1Marker,
+        ExemplarCitiesV1Marker,
+        MetaZoneGenericNamesLongV1Marker,
+        MetaZoneGenericNamesShortV1Marker,
+        MetaZoneSpecificNamesLongV1Marker,
+        MetaZoneSpecificNamesShortV1Marker,
+    ],
+    SERDE_SE
+);
 
 impl_data_provider!(TimeZoneFormatsV1, TimeZoneFormatsV1Marker);
 impl_data_provider!(ExemplarCitiesV1, ExemplarCitiesV1Marker);
@@ -158,14 +166,9 @@ mod tests {
         let provider = TimeZonesProvider::try_from(&cldr_paths as &dyn CldrPaths).unwrap();
 
         let time_zone_formats: DataPayload<TimeZoneFormatsV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::TIMEZONE_FORMATS_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("en")),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: langid!("en").into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -173,14 +176,9 @@ mod tests {
         assert_eq!("GMT", time_zone_formats.get().gmt_zero_format);
 
         let exemplar_cities: DataPayload<ExemplarCitiesV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::TIMEZONE_EXEMPLAR_CITIES_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("en")),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: langid!("en").into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -188,14 +186,9 @@ mod tests {
         assert_eq!("Pohnpei", exemplar_cities.get()["Pacific/Ponape"]);
 
         let generic_names_long: DataPayload<MetaZoneGenericNamesLongV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::TIMEZONE_GENERIC_NAMES_LONG_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("en")),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: langid!("en").into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -206,14 +199,9 @@ mod tests {
         );
 
         let specific_names_long: DataPayload<MetaZoneSpecificNamesLongV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::TIMEZONE_SPECIFIC_NAMES_LONG_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("en")),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: langid!("en").into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -224,14 +212,9 @@ mod tests {
         );
 
         let generic_names_short: DataPayload<MetaZoneGenericNamesShortV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::TIMEZONE_GENERIC_NAMES_SHORT_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("en")),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: langid!("en").into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
@@ -239,14 +222,9 @@ mod tests {
         assert_eq!("PT", generic_names_short.get()["America_Pacific"]);
 
         let specific_names_short: DataPayload<MetaZoneSpecificNamesShortV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::TIMEZONE_SPECIFIC_NAMES_SHORT_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("en")),
-                    },
-                },
+            .load_resource(&DataRequest {
+                options: langid!("en").into(),
+                metadata: Default::default(),
             })
             .unwrap()
             .take_payload()
diff --git a/provider/core/README.md b/provider/core/README.md
index 90c14da370c..bffe3b760ff 100644
--- a/provider/core/README.md
+++ b/provider/core/README.md
@@ -2,91 +2,103 @@
 
 `icu_provider` is one of the [`ICU4X`] components.
 
-It defines traits and structs for transmitting data through the ICU4X locale data pipeline.
-The primary trait is [`DataProvider`]. It has one method, which transforms a [`Request`] into
-a [`Response`]:
+`icu_provider` defines traits and structs for transmitting data through the ICU4X locale
+data pipeline. The primary trait is [`ResourceProvider`]. It is parameterized by a
+[`ResourceMarker`], which contains the data type and a [`ResourceKey`]. It has one method,
+[`ResourceProvider::load_resource`], which transforms a [`DataRequest`]
+into a [`DataResponse`].
 
-```rust
-fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<'data>, DataError>
-```
+- [`ResourceKey`] is a fixed identifier for the data type, such as `"plurals/cardinal@1"`.
+- [`DataRequest`] contains additional annotations to choose a specific variant of the key,
+  such as a locale.
+- [`DataResponse`] contains the data if the request was successful.
 
-A [`Request`] contains a [`ResourceKey`] (a fixed identifier such as "plurals/cardinal@1") and
-[`ResourceOptions`] (a language identifier and optional variant, e.g. "fr") being requested.
-The Response contains the data payload corresponding to the Request.
+In addition, there are three other traits which are widely implemented:
 
-A [`Response`] contains a [`DataPayload`] along with other metadata.
+- [`AnyProvider`] returns data as `dyn Any` trait objects.
+- [`BufferProvider`] returns data as `[u8]` buffers.
+- [`DynProvider`] returns structured data but is not specific to a key.
 
-The most common types required for ICU4X [`DataProvider`] are included via the prelude:
+The most common types required for this crate are included via the prelude:
 
 ```rust
 use icu_provider::prelude::*;
 ```
 
-### Concrete Implementations of Data Providers
+### Types of Data Providers
+
+All nontrivial data providers can fit into one of two classes.
+
+1. Type 1: Those whose data originates as structured Rust objects
+2. Type 2: Those whose data originates as unstructured `[u8]` buffers
+
+#### Type 1 Providers
+
+Type 1 providers generally implement [`AnyProvider`], which returns structured data cast into
+`dyn Any` trait objects. Users can call [`as_downcasting()`] to get an object implementing
+[`ResourceProvider`] by downcasting the trait objects.
+
+Examples of Type 1 providers:
+
+- [`CldrJsonDataProvider`] reads structured data from CLDR JSON source files and returns
+  structured Rust objects.
+- [`AnyPayloadProvider`] wraps a specific data struct and returns it.
+- The upcoming `crabbake` provider which reads structured data from Rust source files
+
+#### Type 2 Providers
+
+Type 2 providers generally implement [`BufferProvider`], which returns unstructured data
+typically represented as [`serde`]-serialized buffers. Users can call [`as_deserializing()`]
+to get an object implementing [`ResourceProvider`] by invoking Serde Deserialize.
+
+Examples of Type 2 providers:
 
-Any object implementing [`DataProvider`] can be used to supply ICU4X with locale data. ICU4X ships
-with some pre-built data providers:
+- [`FsDataProvider`] reads individual buffers from the filesystem.
+- [`BlobDataProvider`] reads buffers from a large in-memory blob.
 
-- [`CldrJsonDataProvider`](../icu_provider_cldr/transform/struct.CldrJsonDataProvider.html) reads structured
-  data directly from CLDR source files.
-- [`FsDataProvider`](../icu_provider_fs/struct.FsDataProvider.html) reads structured data from the
-  filesystem. It can also write out that filesystem structure. More efficient than CldrJsonDataProvider.
+#### Special-Purpose Providers
 
 This crate also contains some concrete implementations for testing purposes:
 
 - [`InvariantDataProvider`] returns fixed data that does not vary by locale.
-- [`AnyPayloadProvider`] wraps a particular instance of a struct and returns it.
 - [`HelloWorldProvider`] returns "hello world" strings in several languages.
 
+### Combinatorial Providers
+
+ICU4X offers several built-in modules to combine providers in interesting ways:
+
+- Use the [`fork`] module to marshall data requests between multiple possible providers.
+- Use the [`either`] module to choose between multiple provider types at runtime.
+- Use the [`filter`] module to programmatically reject certain data requests.
+
 ### Types and Lifetimes
 
 Types compatible with [`Yokeable`] can be passed through the data provider, so long as they are
 associated with a marker type implementing [`DataMarker`].
 
-Most [`DataProvider`] traits take one lifetime argument: `'data`. This lifetime allows data
-structs to borrow zero-copy data. In practice, it also represents the lifetime of data that
-the Cart of the Yoke of the DataPayload borrows; for more information on carts and yokes,
-see [`yoke`].
+Data structs should generally have one lifetime argument: `'data`. This lifetime allows data
+structs to borrow zero-copy data.
 
 ### Additional Traits
 
 #### `IterableDataProvider`
 
-Data providers can implement [`IterableProvider`], allowing iteration over all [`ResourceOptions`]
-instances supported for a certain key in the data provider.
+Data providers can implement [`IterableProvider`], allowing iteration over all
+[`ResourceOptions`] instances supported for a certain key in the data provider.
 
 For more information, see the [`iter`] module.
 
-#### `BufferProvider`
-
-The trait [`BufferProvider`] represents a data provider that produces buffers (`[u8]`), which
-are typically deserialized later via Serde. This allows for a Serde-enabled provider
-to be saved as a trait object without being specific to a data struct type.
-
-#### `AnyProvider`
-
-The trait [`AnyProvider`] removes the type argument from [`DataProvider`] and requires
-that all data structs be convertible to the [`Any`](core::any::Any) type. This enables the
-processing of data without the caller knowing the underlying data struct.
-
-Since [`AnyProvider`] is not specific to a single type, it can be useful for caches or
-other bulk data operations.
-
 #### `DataProvider<SerializeMarker>`
 
 *Enabled with the "serialize" feature*
 
-Data providers capable of returning opaque `erased_serde::Serialize` trait objects can be used as
-input to a data exporter, such as when writing data to the filesystem.
-
-This trait is normally implemented using the [`impl_dyn_provider!`] macro.
+Data providers capable of returning opaque `erased_serde::Serialize` trait objects can be use
+as input to a data exporter, such as when writing data to the filesystem.
 
 This trait is normally implemented using the [`impl_dyn_provider!`] macro.
 
 [`ICU4X`]: ../icu/index.html
 [`DataProvider`]: data_provider::DataProvider
-[`Request`]: data_provider::DataRequest
-[`Response`]: data_provider::DataResponse
 [`ResourceKey`]: resource::ResourceKey
 [`ResourceOptions`]: resource::ResourceOptions
 [`IterableProvider`]: iter::IterableProvider
@@ -96,6 +108,11 @@ This trait is normally implemented using the [`impl_dyn_provider!`] macro.
 [`AnyProvider`]: any::AnyProvider
 [`Yokeable`]: yoke::Yokeable
 [`impl_dyn_provider!`]: impl_dyn_provider
+[`as_downcasting()`]: AsDowncastingAnyProvider::as_downcasting
+[`as_deserializing()`]: AsDeserializingBufferProvider::as_deserializing
+[`CldrJsonDataProvider`]: ../icu_provider_cldr/struct.CldrJsonDataProvider.html
+[`FsDataProvider`]: ../icu_provider_fs/struct.FsDataProvider.html
+[`BlobDataProvider`]: ../icu_provider_blob/struct.BlobDataProvider.html
 
 ## More Information
 
diff --git a/provider/core/src/any.rs b/provider/core/src/any.rs
index 00b289ef312..3f73e8b3126 100644
--- a/provider/core/src/any.rs
+++ b/provider/core/src/any.rs
@@ -271,7 +271,8 @@ impl AnyResponse {
 ///     data: AnyPayload::from_static_ref(&CONST_DATA),
 /// };
 ///
-/// let any_response = provider.load_any(&DataRequest::from(key::HELLO_WORLD_V1))
+/// let any_response = provider
+///     .load_any(key::HELLO_WORLD_V1, &DataRequest::default())
 ///     .expect("Load should succeed");
 ///
 /// // Downcast to something useful
@@ -286,52 +287,42 @@ impl AnyResponse {
 ///
 /// [`AnyPayloadProvider`]: crate::struct_provider::AnyPayloadProvider
 pub trait AnyProvider {
-    fn load_any(&self, req: &DataRequest) -> Result<AnyResponse, DataError>;
+    fn load_any(&self, key: ResourceKey, req: &DataRequest) -> Result<AnyResponse, DataError>;
 }
 
-impl<P> DataProvider<AnyMarker> for P
-where
-    P: AnyProvider + ?Sized,
-{
-    #[inline]
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<AnyMarker>, DataError> {
-        self.load_any(req).map(|r| r.into())
-    }
-}
+/// A wrapper over `DynProvider<AnyMarker>` that implements `AnyProvider`
+pub struct DynProviderAnyMarkerWrap<'a, P: ?Sized>(pub &'a P);
 
-/// A wrapper over `DataProvider<AnyMarker>` that implements `AnyProvider`
-pub struct DataProviderAnyMarkerWrap<'a, P: ?Sized>(pub &'a P);
-
-pub trait AsDataProviderAnyMarkerWrap {
-    /// Returns an object implementing `AnyProvider` when called on `DataProvider<AnyMarker>`
-    fn as_any_provider(&self) -> DataProviderAnyMarkerWrap<Self>;
+pub trait AsDynProviderAnyMarkerWrap {
+    /// Returns an object implementing `AnyProvider` when called on `DynProvider<AnyMarker>`
+    fn as_any_provider(&self) -> DynProviderAnyMarkerWrap<Self>;
 }
 
-impl<P> AsDataProviderAnyMarkerWrap for P
+impl<P> AsDynProviderAnyMarkerWrap for P
 where
-    P: DataProvider<AnyMarker>,
+    P: DynProvider<AnyMarker>,
 {
     #[inline]
-    fn as_any_provider(&self) -> DataProviderAnyMarkerWrap<P> {
-        DataProviderAnyMarkerWrap(self)
+    fn as_any_provider(&self) -> DynProviderAnyMarkerWrap<P> {
+        DynProviderAnyMarkerWrap(self)
     }
 }
 
-impl<P> AnyProvider for DataProviderAnyMarkerWrap<'_, P>
+impl<P> AnyProvider for DynProviderAnyMarkerWrap<'_, P>
 where
-    P: DataProvider<AnyMarker> + ?Sized,
+    P: DynProvider<AnyMarker> + ?Sized,
 {
     #[inline]
-    fn load_any(&self, req: &DataRequest) -> Result<AnyResponse, DataError> {
-        self.0.load_payload(req)?.try_into()
+    fn load_any(&self, key: ResourceKey, req: &DataRequest) -> Result<AnyResponse, DataError> {
+        self.0.load_payload(key, req)?.try_into()
     }
 }
 
-/// A wrapper over `AnyProvider` that implements `DataProvider<M>` via downcasting
+/// A wrapper over `AnyProvider` that implements `DynProvider<M>` via downcasting
 pub struct DowncastingAnyProvider<'a, P: ?Sized>(pub &'a P);
 
 pub trait AsDowncastingAnyProvider {
-    /// Returns an object implementing `DataProvider<M>` when called on `AnyProvider`
+    /// Returns an object implementing `DynProvider<M>` when called on `AnyProvider`
     fn as_downcasting(&self) -> DowncastingAnyProvider<Self>;
 }
 
@@ -345,16 +336,16 @@ where
     }
 }
 
-impl<M, P> DataProvider<M> for DowncastingAnyProvider<'_, P>
+impl<M, P> ResourceProvider<M> for DowncastingAnyProvider<'_, P>
 where
     P: AnyProvider + ?Sized,
-    M: DataMarker + 'static,
+    M: ResourceMarker + 'static,
     for<'a> YokeTraitHack<<M::Yokeable as Yokeable<'a>>::Output>: Clone,
     M::Yokeable: ZeroCopyFrom<'static, M::Yokeable>,
 {
     #[inline]
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
-        self.0.load_any(req)?.downcast()
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+        self.0.load_any(M::KEY, req)?.downcast()
     }
 }
 
diff --git a/provider/core/src/buf.rs b/provider/core/src/buf.rs
index 8fd929e4805..ebf5819c8ed 100644
--- a/provider/core/src/buf.rs
+++ b/provider/core/src/buf.rs
@@ -15,10 +15,10 @@ impl DataMarker for BufferMarker {
 /// A data provider that returns opaque bytes.
 ///
 /// Generally, these bytes are expected to be deserializable with Serde. To get an object
-/// implementing [`DataProvider`] via Serde, use [`as_deserializing()`], which requires
+/// implementing [`ResourceProvider`] via Serde, use [`as_deserializing()`], which requires
 /// enabling at least one of the Serde features.
 ///
-/// Along with [`DataProvider`], this is one of the two foundational traits in this crate.
+/// Along with [`ResourceProvider`], this is one of the two foundational traits in this crate.
 ///
 /// # Examples
 ///
@@ -34,14 +34,9 @@ impl DataMarker for BufferMarker {
 /// let data_provider = buffer_provider.as_deserializing();
 ///
 /// let german_hello_world: DataPayload<HelloWorldV1Marker> = data_provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("de")),
-///             }
-///         }
+///     .load_resource(&DataRequest {
+///         options: langid!("de").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect("Loading should succeed")
 ///     .take_payload()
@@ -53,7 +48,11 @@ impl DataMarker for BufferMarker {
 ///
 /// [`as_deserializing()`]: AsDeserializingBufferProvider::as_deserializing
 pub trait BufferProvider {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError>;
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError>;
 }
 
 /// An enum expressing all Serde formats known to ICU4X.
diff --git a/provider/core/src/data_provider.rs b/provider/core/src/data_provider.rs
index bf1fd2e5011..1694b8019b6 100644
--- a/provider/core/src/data_provider.rs
+++ b/provider/core/src/data_provider.rs
@@ -8,9 +8,9 @@ mod test;
 
 use crate::buf::BufferMarker;
 use crate::error::{DataError, DataErrorKind};
-use crate::marker::DataMarker;
+use crate::marker::{DataMarker, ResourceMarker};
 use crate::resource::ResourceKey;
-use crate::resource::ResourcePath;
+use crate::resource::ResourceOptions;
 use crate::yoke::trait_hack::YokeTraitHack;
 use crate::yoke::*;
 
@@ -22,76 +22,54 @@ use core::fmt::Debug;
 use core::marker::PhantomData;
 use icu_locid::LanguageIdentifier;
 
-/// A struct to request a certain piece of data from a data provider.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Default)]
+#[non_exhaustive]
+pub struct DataRequestMetadata;
+
+#[derive(Default)]
 pub struct DataRequest {
-    pub resource_path: ResourcePath,
+    pub options: ResourceOptions,
+    pub metadata: DataRequestMetadata,
 }
 
 impl fmt::Display for DataRequest {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "{}/{}",
-            self.resource_path.key, self.resource_path.options
-        )
-    }
-}
-
-/// Create a [`DataRequest`] to a particular [`ResourceKey`] with default options.
-impl From<ResourceKey> for DataRequest {
-    fn from(key: ResourceKey) -> Self {
-        Self {
-            resource_path: ResourcePath {
-                key,
-                options: Default::default(),
-            },
-        }
+        fmt::Display::fmt(&self.options, f)
     }
 }
 
 impl DataRequest {
-    /// Returns the [`LanguageIdentifier`] for this [`DataRequest`], or an error if it is not present.
+    /// Returns the [`LanguageIdentifier`] for this [`DataRequest`], or `None` if it is not present.
     ///
     /// # Examples
     ///
     /// ```
     /// use icu_provider::prelude::*;
+    /// use icu_locid_macros::langid;
     ///
     /// const FOO_BAR: ResourceKey = icu_provider::resource_key!("foo/bar@1");
     ///
     /// let req_no_langid = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: FOO_BAR,
-    ///         options: ResourceOptions::default(),
-    ///     }
+    ///     options: ResourceOptions::default(),
+    ///     metadata: Default::default(),
     /// };
     ///
     /// let req_with_langid = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: FOO_BAR,
-    ///         options: ResourceOptions {
-    ///             variant: None,
-    ///             langid: Some(icu_locid_macros::langid!("ar-EG")),
-    ///         },
-    ///     }
+    ///     options: langid!("ar-EG").into(),
+    ///     metadata: Default::default(),
     /// };
     ///
     /// assert!(matches!(
-    ///     req_no_langid.try_langid(),
-    ///     Err(DataError { kind: DataErrorKind::NeedsLocale, .. })
+    ///     req_no_langid.get_langid(),
+    ///     None
     /// ));
     /// assert!(matches!(
-    ///     req_with_langid.try_langid(),
-    ///     Ok(_)
+    ///     req_with_langid.get_langid(),
+    ///     Some(_)
     /// ));
     /// ```
-    pub fn try_langid(&self) -> Result<&LanguageIdentifier, DataError> {
-        self.resource_path
-            .options
-            .langid
-            .as_ref()
-            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(self))
+    pub fn get_langid(&self) -> Option<&LanguageIdentifier> {
+        self.options.langid.as_ref()
     }
 }
 
@@ -105,7 +83,7 @@ pub struct DataResponseMetadata {
     pub buffer_format: Option<crate::buf::BufferFormat>,
 }
 
-/// A container for data payloads returned from a [`DataProvider`].
+/// A container for data payloads returned from a data provider.
 ///
 /// [`DataPayload`] is built on top of the [`yoke`] framework, which allows for cheap, zero-copy
 /// operations on data via the use of self-references. A [`DataPayload`] may be backed by one of
@@ -804,6 +782,14 @@ where
             yoke: self.yoke.try_project_cloned_with_capture(capture, f)?,
         })
     }
+
+    #[inline]
+    pub fn cast<M2>(self) -> DataPayload<M2>
+    where
+        M2: DataMarker<Yokeable = M::Yokeable>,
+    {
+        DataPayload { yoke: self.yoke }
+    }
 }
 
 impl DataPayload<BufferMarker> {
@@ -939,14 +925,13 @@ fn test_debug() {
     assert_eq!("DataResponse { metadata: DataResponseMetadata { data_langid: None, buffer_format: None }, payload: Some(HelloWorldV1 { message: \"foo\" }) }", format!("{:?}", resp));
 }
 
-/// A generic data provider that loads a payload of a specific type.
+/// A data provider that loads data for a specific data type.
 ///
-/// See examples on some of the concrete implementations:
+/// Unlike [`ResourceProvider`], there may be multiple keys corresponding to the same data type.
+/// This is often the case when returning `dyn` trait objects such as [`SerializeMarker`].
 ///
-/// - [`HelloWorldProvider`](crate::hello_world::HelloWorldProvider)
-/// - [`AnyPayloadProvider`](crate::struct_provider::AnyPayloadProvider)
-/// - [`InvariantDataProvider`](crate::inv::InvariantDataProvider)
-pub trait DataProvider<M>
+/// [`SerializeMarker`]: crate::serde::SerializeMarker
+pub trait DynProvider<M>
 where
     M: DataMarker,
 {
@@ -954,5 +939,21 @@ where
     ///
     /// Returns [`Ok`] if the request successfully loaded data. If data failed to load, returns an
     /// Error with more information.
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError>;
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError>;
+}
+
+/// A data provider that loads data for a specific [`ResourceKey`].
+pub trait ResourceProvider<M>
+where
+    M: ResourceMarker,
+{
+    /// Query the provider for data, returning the result.
+    ///
+    /// Returns [`Ok`] if the request successfully loaded data. If data failed to load, returns an
+    /// Error with more information.
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError>;
 }
diff --git a/provider/core/src/data_provider/test.rs b/provider/core/src/data_provider/test.rs
index 1c467801ffd..a133aa3fd01 100644
--- a/provider/core/src/data_provider/test.rs
+++ b/provider/core/src/data_provider/test.rs
@@ -32,6 +32,10 @@ impl DataMarker for HelloAltMarker {
     type Yokeable = HelloAlt;
 }
 
+impl ResourceMarker for HelloAltMarker {
+    const KEY: ResourceKey = HELLO_ALT_KEY;
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
 struct HelloCombined<'data> {
     #[serde(borrow)]
@@ -47,12 +51,11 @@ struct DataWarehouse {
     hello_alt: HelloAlt,
 }
 
-impl DataProvider<HelloWorldV1Marker> for DataWarehouse {
-    fn load_payload(
+impl ResourceProvider<HelloWorldV1Marker> for DataWarehouse {
+    fn load_resource(
         &self,
-        req: &DataRequest,
+        _: &DataRequest,
     ) -> Result<DataResponse<HelloWorldV1Marker>, DataError> {
-        req.resource_path.key.match_key(key::HELLO_WORLD_V1)?;
         Ok(DataResponse {
             metadata: DataResponseMetadata::default(),
             payload: Some(DataPayload::from_owned(self.hello_v1.clone())),
@@ -60,9 +63,7 @@ impl DataProvider<HelloWorldV1Marker> for DataWarehouse {
     }
 }
 
-crate::impl_dyn_provider!(DataWarehouse, {
-    key::HELLO_WORLD_V1 => HelloWorldV1Marker,
-}, ANY);
+crate::impl_dyn_provider!(DataWarehouse, [HelloWorldV1Marker,], ANY);
 
 /// A DataProvider that supports both key::HELLO_WORLD_V1 and HELLO_ALT.
 #[derive(Debug)]
@@ -76,12 +77,11 @@ impl From<DataWarehouse> for DataProvider2 {
     }
 }
 
-impl DataProvider<HelloWorldV1Marker> for DataProvider2 {
-    fn load_payload(
+impl ResourceProvider<HelloWorldV1Marker> for DataProvider2 {
+    fn load_resource(
         &self,
-        req: &DataRequest,
+        _: &DataRequest,
     ) -> Result<DataResponse<HelloWorldV1Marker>, DataError> {
-        req.resource_path.key.match_key(key::HELLO_WORLD_V1)?;
         Ok(DataResponse {
             metadata: DataResponseMetadata::default(),
             payload: Some(DataPayload::from_owned(self.data.hello_v1.clone())),
@@ -89,9 +89,8 @@ impl DataProvider<HelloWorldV1Marker> for DataProvider2 {
     }
 }
 
-impl DataProvider<HelloAltMarker> for DataProvider2 {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<HelloAltMarker>, DataError> {
-        req.resource_path.key.match_key(HELLO_ALT_KEY)?;
+impl ResourceProvider<HelloAltMarker> for DataProvider2 {
+    fn load_resource(&self, _: &DataRequest) -> Result<DataResponse<HelloAltMarker>, DataError> {
         Ok(DataResponse {
             metadata: DataResponseMetadata::default(),
             payload: Some(DataPayload::from_owned(self.data.hello_alt.clone())),
@@ -99,10 +98,7 @@ impl DataProvider<HelloAltMarker> for DataProvider2 {
     }
 }
 
-crate::impl_dyn_provider!(DataProvider2, {
-    key::HELLO_WORLD_V1 => HelloWorldV1Marker,
-    HELLO_ALT_KEY => HelloAltMarker,
-}, ANY);
+crate::impl_dyn_provider!(DataProvider2, [HelloWorldV1Marker, HelloAltMarker,], ANY);
 
 #[allow(clippy::redundant_static_lifetimes)]
 const DATA: &'static str = r#"{
@@ -123,34 +119,16 @@ fn get_warehouse(data: &'static str) -> DataWarehouse {
     }
 }
 
-fn get_payload_v1<P: DataProvider<HelloWorldV1Marker> + ?Sized>(
+fn get_payload_v1<P: ResourceProvider<HelloWorldV1Marker> + ?Sized>(
     provider: &P,
 ) -> Result<DataPayload<HelloWorldV1Marker>, DataError> {
-    provider.load_payload(&get_request_v1())?.take_payload()
+    provider.load_resource(&Default::default())?.take_payload()
 }
 
-fn get_payload_alt<P: DataProvider<HelloAltMarker> + ?Sized>(
-    d: &P,
+fn get_payload_alt<P: ResourceProvider<HelloAltMarker> + ?Sized>(
+    provider: &P,
 ) -> Result<DataPayload<HelloAltMarker>, DataError> {
-    d.load_payload(&get_request_alt())?.take_payload()
-}
-
-fn get_request_v1() -> DataRequest {
-    DataRequest {
-        resource_path: ResourcePath {
-            key: key::HELLO_WORLD_V1,
-            options: Default::default(),
-        },
-    }
-}
-
-fn get_request_alt() -> DataRequest {
-    DataRequest {
-        resource_path: ResourcePath {
-            key: HELLO_ALT_KEY,
-            options: Default::default(),
-        },
-    }
+    provider.load_resource(&Default::default())?.take_payload()
 }
 
 #[test]
@@ -180,7 +158,8 @@ fn test_warehouse_owned_dyn_erased() {
 #[test]
 fn test_warehouse_owned_dyn_generic() {
     let warehouse = get_warehouse(DATA);
-    let hello_data = get_payload_v1(&warehouse as &dyn DataProvider<HelloWorldV1Marker>).unwrap();
+    let hello_data =
+        get_payload_v1(&warehouse as &dyn ResourceProvider<HelloWorldV1Marker>).unwrap();
     assert!(matches!(
         hello_data.get(),
         HelloWorldV1 {
@@ -240,7 +219,8 @@ fn test_provider2_dyn_erased_alt() {
 fn test_provider2_dyn_generic() {
     let warehouse = get_warehouse(DATA);
     let provider = DataProvider2::from(warehouse);
-    let hello_data = get_payload_v1(&provider as &dyn DataProvider<HelloWorldV1Marker>).unwrap();
+    let hello_data =
+        get_payload_v1(&provider as &dyn ResourceProvider<HelloWorldV1Marker>).unwrap();
     assert!(matches!(
         hello_data.get(),
         HelloWorldV1 {
@@ -253,7 +233,7 @@ fn test_provider2_dyn_generic() {
 fn test_provider2_dyn_generic_alt() {
     let warehouse = get_warehouse(DATA);
     let provider = DataProvider2::from(warehouse);
-    let hello_data = get_payload_alt(&provider as &dyn DataProvider<HelloAltMarker>).unwrap();
+    let hello_data = get_payload_alt(&provider as &dyn ResourceProvider<HelloAltMarker>).unwrap();
     assert!(matches!(hello_data.get(), HelloAlt { .. }));
 }
 
@@ -262,10 +242,13 @@ fn test_mismatched_types() {
     let warehouse = get_warehouse(DATA);
     let provider = DataProvider2::from(warehouse);
     // Request is for v2, but type argument is for v1
-    let response: Result<DataResponse<HelloWorldV1Marker>, DataError> =
-        AnyProvider::load_any(&provider.as_any_provider(), &get_request_alt())
-            .unwrap()
-            .downcast();
+    let response: Result<DataResponse<HelloWorldV1Marker>, DataError> = AnyProvider::load_any(
+        &provider.as_any_provider(),
+        HELLO_ALT_KEY,
+        &Default::default(),
+    )
+    .unwrap()
+    .downcast();
     assert!(matches!(
         response,
         Err(DataError {
@@ -277,15 +260,15 @@ fn test_mismatched_types() {
 
 fn check_v1_v2<P>(d: &P)
 where
-    P: DataProvider<HelloWorldV1Marker> + DataProvider<HelloAltMarker> + ?Sized,
+    P: ResourceProvider<HelloWorldV1Marker> + ResourceProvider<HelloAltMarker> + ?Sized,
 {
     let v1: DataPayload<HelloWorldV1Marker> = d
-        .load_payload(&get_request_v1())
+        .load_resource(&Default::default())
         .unwrap()
         .take_payload()
         .unwrap();
     let v2: DataPayload<HelloAltMarker> = d
-        .load_payload(&get_request_alt())
+        .load_resource(&Default::default())
         .unwrap()
         .take_payload()
         .unwrap();
diff --git a/provider/core/src/dynutil.rs b/provider/core/src/dynutil.rs
index 56e2a023ad2..e4749d53838 100644
--- a/provider/core/src/dynutil.rs
+++ b/provider/core/src/dynutil.rs
@@ -11,8 +11,8 @@
 /// [`DataPayload::downcast`]: crate::DataPayload::downcast
 pub trait UpcastDataPayload<M>
 where
-    M: crate::prelude::DataMarker,
-    Self: Sized + crate::prelude::DataMarker,
+    M: crate::DataMarker,
+    Self: Sized + crate::DataMarker,
 {
     /// Upcast a `DataPayload<T>` to a `DataPayload<S>` where `T` implements trait `S`.
     ///
@@ -35,93 +35,111 @@ where
     ///     .expect("Type conversion");
     /// assert_eq!(downcasted.get(), "foo");
     /// ```
-    fn upcast(other: crate::prelude::DataPayload<M>) -> crate::prelude::DataPayload<Self>;
+    fn upcast(other: crate::DataPayload<M>) -> crate::DataPayload<Self>;
 }
 
-/// Implements [`DataProvider`] for a marker type `S` on a type that already implements
-/// [`DataProvider`] for one or more `M`, where `M` is a concrete type that is convertible to `S`
-/// via [`UpcastDataPayload`].
+/// Implements [`DynProvider`] for a marker type `S` on a type that already implements
+/// [`DynProvider`] or [`ResourceProvider`] for one or more `M`, where `M` is a concrete type
+/// that is convertible to `S` via [`UpcastDataPayload`].
 ///
 /// Use this macro to add support to your data provider for:
 ///
-/// - [`AnyPayload`] if your provider can return typed objects as [`Any`](core::any::Any)
+/// - [`AnyPayload`] if your provider can return typed objects as [`Any`](core::any::Any).
+///   Use the shorthand `ANY` as the third argument to the macro.
 /// - [`SerializeMarker`] if your provider returns objects implementing [`serde::Serialize`]
+///   Use the shorthand `SERDE_SE` as the third argument to the macro.
 ///
-/// The second argument is a match-like construction mapping from resource keys to structs. To map
-/// multiple keys to a single data struct, use `_` as the data key.
+/// ## Wrapping ResourceProvider
 ///
-/// The third argument can be either the trait object marker, like [`SerializeMarker`], or the
-/// shorthands `ANY` or `SERDE_SE`.
+/// If your type implements [`ResourceProvider`], pass a list of markers as the second argument.
+/// This results in a `DynProvider<AnyMarker>` that delegates to a specific marker if the key
+/// matches or else returns [`DataErrorKind::MissingResourceKey`].
 ///
-/// Lifetimes:
+/// ```
+/// use icu_provider::prelude::*;
+/// use icu_provider::hello_world::*;
+/// use icu_provider::inv::InvariantDataProvider;
+///
+/// // Example struct that implements ResourceProvider<HelloWorldV1Marker>
+/// struct MyProvider;
+/// impl ResourceProvider<HelloWorldV1Marker> for MyProvider {
+///     fn load_resource(&self, req: &DataRequest)
+///             -> Result<DataResponse<HelloWorldV1Marker>, DataError> {
+///         let provider = InvariantDataProvider;
+///         provider.load_resource(req)
+///     }
+/// }
 ///
-/// - `$data` is the lifetime parameter for [`DataProvider`](crate::DataProvider); usually `'data`.
+/// // Implement DataProvider<AnyMarker> on this struct
+/// icu_provider::impl_dyn_provider!(MyProvider, [
+///     HelloWorldV1Marker,
+/// ], ANY);
+///
+/// let provider = MyProvider;
+///
+/// // Successful result if the key matches:
+/// assert!(matches!(
+///     provider.load_payload(HelloWorldV1Marker::KEY, &Default::default()),
+///     Ok(_)
+/// ));
+///
+/// // Failure if the key does not match:
+/// let DUMMY_KEY = icu_provider::resource_key!("dummy@1");
+/// assert!(matches!(
+///     provider.load_payload(DUMMY_KEY, &Default::default()),
+///     Err(DataError { kind: DataErrorKind::MissingResourceKey, .. })
+/// ));
+/// ```
 ///
-/// # Examples
+/// ## Wrapping DynProvider
 ///
-/// Basic usage:
+/// It is also possible to wrap a [`DynProvider`] to create another [`DynProvider`]. To do this,
+/// pass a match-like statement for keys as the second argument:
 ///
 /// ```
 /// use icu_provider::prelude::*;
-/// use icu_provider::marker::CowStrMarker;
-/// use std::borrow::Cow;
-/// const DEMO_KEY: ResourceKey = icu_provider::resource_key!("foo/bar@1");
-///
-/// // A small DataProvider that returns owned strings
-/// struct MyProvider(pub String);
-/// impl DataProvider<CowStrMarker> for MyProvider {
-///     fn load_payload(&self, req: &DataRequest)
-///             -> Result<DataResponse<CowStrMarker>, DataError> {
-///         req.resource_path.key.match_key(DEMO_KEY)?;
-///         Ok(DataResponse {
-///             metadata: Default::default(),
-///             payload: Some(DataPayload::from_owned(Cow::Owned(self.0.to_string())))
-///         })
+/// use icu_provider::hello_world::*;
+/// use icu_provider::inv::InvariantDataProvider;
+///
+/// // Example struct that implements DynProvider<HelloWorldV1Marker>
+/// struct MyProvider;
+/// impl DynProvider<HelloWorldV1Marker> for MyProvider {
+///     fn load_payload(&self, key: ResourceKey, req: &DataRequest)
+///             -> Result<DataResponse<HelloWorldV1Marker>, DataError> {
+///         let provider = InvariantDataProvider;
+///         provider.load_resource(req)
 ///     }
 /// }
 ///
-/// // Implement DataProvider<AnyMarker>
+/// // Implement DataProvider<AnyMarker> on this struct.
+/// // Match HelloWorldV1Marker::KEY and delegate to DynProvider<HelloWorldV1Marker>.
+/// // Send the wildcard match also to DynProvider<HelloWorldV1Marker>.
 /// icu_provider::impl_dyn_provider!(MyProvider, {
-///     DEMO_KEY => CowStrMarker,
+///     HelloWorldV1Marker::KEY => HelloWorldV1Marker,
+///     _ => HelloWorldV1Marker,
 /// }, ANY);
 ///
-/// // Usage example
-/// let provider = MyProvider("demo".to_string());
-/// let resp: DataResponse<AnyMarker> = provider
-///     .load_payload(&DEMO_KEY.into())
-///     .expect("Loading should succeed");
-/// let payload: DataPayload<CowStrMarker> = resp
-///     .take_payload()
-///     .expect("Payload should be present")
-///     .downcast()
-///     .expect("Type should downcast successfully");
-/// assert_eq!("demo", payload.get());
-/// ```
-///
-/// Using the wildcard `_` match:
-///
-/// ```
-/// # use icu_provider::prelude::*;
-/// # use icu_provider::marker::CowStrMarker;
-/// # use std::borrow::Cow;
-/// # struct MyProvider(pub String);
-/// # impl DataProvider<CowStrMarker> for MyProvider {
-/// #   fn load_payload(&self, req: &DataRequest)
-/// #           -> Result<DataResponse<CowStrMarker>, DataError> {
-/// #       Ok(DataResponse {
-/// #           metadata: Default::default(),
-/// #           payload: Some(DataPayload::from_owned(self.0.to_string().into()))
-/// #       })
-/// #   }
-/// # }
-/// // Send all keys to the `CowStrMarker` provider.
-/// icu_provider::impl_dyn_provider!(MyProvider, {
-///     _ => CowStrMarker,
-/// }, ANY);
+/// let provider = MyProvider;
+/// let provider = provider.as_any_provider();
+///
+/// // Successful result if the key matches:
+/// assert!(matches!(
+///     provider.load_any(HelloWorldV1Marker::KEY, &Default::default()),
+///     Ok(_)
+/// ));
+///
+/// // Because of the wildcard, non-matching requests are captured:
+/// let DUMMY_KEY = icu_provider::resource_key!("dummy@1");
+/// assert!(matches!(
+///     provider.load_any(DUMMY_KEY, &Default::default()),
+///     Ok(_)
+/// ));
 /// ```
 ///
-/// [`DataProvider`]: crate::DataProvider
+/// [`DynProvider`]: crate::DynProvider
+/// [`ResourceProvider`]: crate::ResourceProvider
 /// [`AnyPayload`]: (crate::any::AnyPayload)
+/// [`DataErrorKind::MissingResourceKey`]: (crate::DataErrorKind::MissingResourceKey)
 /// [`SerializeMarker`]: (crate::serde::SerializeMarker)
 #[macro_export]
 macro_rules! impl_dyn_provider {
@@ -132,6 +150,13 @@ macro_rules! impl_dyn_provider {
             $crate::any::AnyMarker
         );
     };
+    ($provider:ty, [ $($struct_m:ty),+, ], ANY) => {
+        $crate::impl_dyn_provider!(
+            $provider,
+            [ $($struct_m),+, ],
+            $crate::any::AnyMarker
+        );
+    };
     ($provider:ty, { $($pat:pat => $struct_m:ty),+, }, SERDE_SE) => {
         // If this fails to compile, enable the "serialize" feature on this crate.
         $crate::impl_dyn_provider!(
@@ -140,21 +165,30 @@ macro_rules! impl_dyn_provider {
             $crate::serde::SerializeMarker
         );
     };
+    ($provider:ty, [ $($struct_m:ty),+, ], SERDE_SE) => {
+        // If this fails to compile, enable the "serialize" feature on this crate.
+        $crate::impl_dyn_provider!(
+            $provider,
+            [ $($struct_m),+, ],
+            $crate::serde::SerializeMarker
+        );
+    };
     ($provider:ty, { $($pat:pat => $struct_m:ty),+, }, $dyn_m:path) => {
-        impl $crate::prelude::DataProvider<$dyn_m> for $provider
+        impl $crate::DynProvider<$dyn_m> for $provider
         {
             fn load_payload(
                 &self,
-                req: &$crate::prelude::DataRequest,
+                key: $crate::ResourceKey,
+                req: &$crate::DataRequest,
             ) -> Result<
-                $crate::prelude::DataResponse<$dyn_m>,
-                $crate::prelude::DataError,
+                $crate::DataResponse<$dyn_m>,
+                $crate::DataError,
             > {
-                match req.resource_path.key {
+                match key {
                     $(
                         $pat => {
-                            let result: $crate::prelude::DataResponse<$struct_m> =
-                                $crate::prelude::DataProvider::load_payload(self, req)?;
+                            let result: $crate::DataResponse<$struct_m> =
+                                $crate::DynProvider::<$struct_m>::load_payload(self, key, req)?;
                             Ok(DataResponse {
                                 metadata: result.metadata,
                                 payload: result.payload.map(|p| {
@@ -165,9 +199,40 @@ macro_rules! impl_dyn_provider {
                     )+,
                     // Don't complain if the call site has its own wildcard match
                     #[allow(unreachable_patterns)]
-                    _ => Err($crate::prelude::DataErrorKind::MissingResourceKey.with_req(req))
+                    _ => Err($crate::DataErrorKind::MissingResourceKey.with_req(key, req))
                 }
             }
         }
-    }
+    };
+    ($provider:ty, [ $($struct_m:ty),+, ], $dyn_m:path) => {
+        impl $crate::DynProvider<$dyn_m> for $provider
+        {
+            fn load_payload(
+                &self,
+                key: $crate::ResourceKey,
+                req: &$crate::DataRequest,
+            ) -> Result<
+                $crate::DataResponse<$dyn_m>,
+                $crate::DataError,
+            > {
+                match key {
+                    $(
+                        <$struct_m as $crate::ResourceMarker>::KEY => {
+                            let result: $crate::DataResponse<$struct_m> =
+                                $crate::ResourceProvider::load_resource(self, req)?;
+                            Ok(DataResponse {
+                                metadata: result.metadata,
+                                payload: result.payload.map(|p| {
+                                    $crate::dynutil::UpcastDataPayload::<$struct_m>::upcast(p)
+                                }),
+                            })
+                        }
+                    )+,
+                    // Don't complain if the call site has its own wildcard match
+                    #[allow(unreachable_patterns)]
+                    _ => Err($crate::DataErrorKind::MissingResourceKey.with_req(key, req))
+                }
+            }
+        }
+    };
 }
diff --git a/provider/core/src/either.rs b/provider/core/src/either.rs
index ad5f19616b3..928af4a8b21 100644
--- a/provider/core/src/either.rs
+++ b/provider/core/src/either.rs
@@ -17,26 +17,58 @@ pub enum EitherProvider<P0, P1> {
     B(P1),
 }
 
+impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for EitherProvider<P0, P1> {
+    #[inline]
+    fn load_any(&self, key: ResourceKey, req: &DataRequest) -> Result<AnyResponse, DataError> {
+        use EitherProvider::*;
+        match self {
+            A(p) => p.load_any(key, req),
+            B(p) => p.load_any(key, req),
+        }
+    }
+}
+
 impl<P0: BufferProvider, P1: BufferProvider> BufferProvider for EitherProvider<P0, P1> {
     #[inline]
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        use EitherProvider::*;
+        match self {
+            A(p) => p.load_buffer(key, req),
+            B(p) => p.load_buffer(key, req),
+        }
+    }
+}
+
+impl<M: DataMarker, P0: DynProvider<M>, P1: DynProvider<M>> DynProvider<M>
+    for EitherProvider<P0, P1>
+{
+    #[inline]
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
         use EitherProvider::*;
         match self {
-            A(p) => p.load_buffer(req),
-            B(p) => p.load_buffer(req),
+            A(p) => p.load_payload(key, req),
+            B(p) => p.load_payload(key, req),
         }
     }
 }
 
-impl<M: DataMarker, P0: DataProvider<M>, P1: DataProvider<M>> DataProvider<M>
+impl<M: ResourceMarker, P0: ResourceProvider<M>, P1: ResourceProvider<M>> ResourceProvider<M>
     for EitherProvider<P0, P1>
 {
     #[inline]
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
         use EitherProvider::*;
         match self {
-            A(p) => p.load_payload(req),
-            B(p) => p.load_payload(req),
+            A(p) => p.load_resource(req),
+            B(p) => p.load_resource(req),
         }
     }
 }
diff --git a/provider/core/src/error.rs b/provider/core/src/error.rs
index fe73ab1ebb0..8accd67c246 100644
--- a/provider/core/src/error.rs
+++ b/provider/core/src/error.rs
@@ -85,8 +85,9 @@ pub enum DataErrorKind {
 ///
 /// ```no_run
 /// # use icu_provider::prelude::*;
+/// let key: ResourceKey = unimplemented!();
 /// let req: &DataRequest = unimplemented!();
-/// DataErrorKind::NeedsVariant.with_req(req);
+/// DataErrorKind::NeedsVariant.with_req(key, req);
 /// ```
 ///
 /// Create a named custom error:
@@ -157,8 +158,8 @@ impl DataErrorKind {
 
     /// Creates a DataError with a request context.
     #[inline]
-    pub fn with_req(self, req: &DataRequest) -> DataError {
-        self.into_error().with_req(req)
+    pub fn with_req(self, key: ResourceKey, req: &DataRequest) -> DataError {
+        self.into_error().with_req(key, req)
     }
 }
 
@@ -203,13 +204,14 @@ impl DataError {
     ///
     /// If the "log_error_context" feature is enabled, this logs the whole request. Either way,
     /// it returns an error with the resource key portion of the request as context.
-    pub fn with_req(self, req: &DataRequest) -> Self {
+    #[cfg_attr(not(feature = "log_error_context"), allow(unused_variables))]
+    pub fn with_req(self, key: ResourceKey, req: &DataRequest) -> Self {
         // Don't write out a log for MissingResourceKey since there is no context to add
         #[cfg(feature = "log_error_context")]
         if self.kind != DataErrorKind::MissingResourceKey {
-            log::warn!("{} (request: {})", self, req);
+            log::warn!("{} (key: {}, request: {})", self, key, req);
         }
-        self.with_key(req.resource_path.key)
+        self.with_key(key)
     }
 
     /// Logs the data error with the given context, then return self.
diff --git a/provider/core/src/export.rs b/provider/core/src/export.rs
index a4f509d67eb..c1b969c8c3e 100644
--- a/provider/core/src/export.rs
+++ b/provider/core/src/export.rs
@@ -7,15 +7,20 @@
 use crate::iter::IterableProvider;
 use crate::prelude::*;
 
-/// An object capable of serializing data payloads to be read by a [`DataProvider`].
+/// An object capable of serializing data payloads to be read by a data provider.
 ///
-/// A [`DataProvider`] by itself is "read-only"; this trait enables it to be "read-write".
+/// A data provider by itself is "read-only"; this trait enables it to be "read-write".
 pub trait DataExporter<M>
 where
     M: DataMarker,
 {
     /// Save a `payload` corresponding to the given data request (resource path).
-    fn put_payload(&mut self, req: DataRequest, payload: DataPayload<M>) -> Result<(), DataError>;
+    fn put_payload(
+        &mut self,
+        key: ResourceKey,
+        req: DataRequest,
+        payload: DataPayload<M>,
+    ) -> Result<(), DataError>;
 
     /// Function called after a key has been fully dumped into the exporter.
     fn flush(&mut self) -> Result<(), DataError> {
@@ -59,20 +64,18 @@ pub fn export_from_iterable<P, E, M>(
 ) -> Result<(), DataError>
 where
     M: DataMarker,
-    P: DataProvider<M> + IterableProvider + ?Sized,
+    P: DynProvider<M> + IterableProvider + ?Sized,
     E: DataExporter<M> + ?Sized,
 {
     let it = provider.supported_options_for_key(resc_key)?;
     let try_export = || -> Result<(), DataError> {
         for options in it {
             let req = DataRequest {
-                resource_path: ResourcePath {
-                    key: *resc_key,
-                    options,
-                },
+                options,
+                metadata: Default::default(),
             };
-            let payload = provider.load_payload(&req)?.take_payload()?;
-            exporter.put_payload(req, payload)?;
+            let payload = provider.load_payload(*resc_key, &req)?.take_payload()?;
+            exporter.put_payload(*resc_key, req, payload)?;
         }
         Ok(())
     };
diff --git a/provider/core/src/filter/impls.rs b/provider/core/src/filter/impls.rs
index 47bac10f6ef..e44bf2cb083 100644
--- a/provider/core/src/filter/impls.rs
+++ b/provider/core/src/filter/impls.rs
@@ -34,24 +34,20 @@ where
     ///
     /// // German requests should succeed:
     /// let req_de = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: key::HELLO_WORLD_V1,
-    ///         options: langid!("de").into(),
-    ///     }
+    ///     options: langid!("de").into(),
+    ///     metadata: Default::default(),
     /// };
     /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load_payload(&req_de);
+    ///     provider.load_resource(&req_de);
     /// assert!(matches!(response, Ok(_)));
     ///
     /// // English requests should fail:
     /// let req_en = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: key::HELLO_WORLD_V1,
-    ///         options: langid!("en-US").into(),
-    ///     }
+    ///     options: langid!("en-US").into(),
+    ///     metadata: Default::default(),
     /// };
     /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load_payload(&req_en);
+    ///     provider.load_resource(&req_en);
     /// assert!(matches!(
     ///     response,
     ///     Err(DataError { kind: DataErrorKind::FilteredResource, .. })
@@ -79,7 +75,7 @@ where
                 if !(old_predicate)(request) {
                     return false;
                 }
-                match &request.resource_path.options.langid {
+                match &request.options.langid {
                     Some(langid) => predicate(langid),
                     None => true,
                 }
@@ -112,24 +108,20 @@ where
     ///
     /// // German requests should succeed:
     /// let req_de = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: key::HELLO_WORLD_V1,
-    ///         options: langid!("de").into(),
-    ///     }
+    ///     options: langid!("de").into(),
+    ///     metadata: Default::default(),
     /// };
     /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load_payload(&req_de);
+    ///     provider.load_resource(&req_de);
     /// assert!(matches!(response, Ok(_)));
     ///
     /// // English requests should fail:
     /// let req_en = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: key::HELLO_WORLD_V1,
-    ///         options: langid!("en-US").into(),
-    ///     }
+    ///     options: langid!("en-US").into(),
+    ///     metadata: Default::default(),
     /// };
     /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load_payload(&req_en);
+    ///     provider.load_resource(&req_en);
     /// assert!(matches!(
     ///     response,
     ///     Err(DataError { kind: DataErrorKind::FilteredResource, .. })
@@ -153,7 +145,7 @@ where
                 if !(old_predicate)(request) {
                     return false;
                 }
-                match &request.resource_path.options.langid {
+                match &request.options.langid {
                     Some(langid) => allowlist.contains(langid),
                     None => true,
                 }
@@ -178,24 +170,20 @@ where
     ///
     /// // Requests with a langid should succeed:
     /// let req_with_langid = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: key::HELLO_WORLD_V1,
-    ///         options: langid!("de").into(),
-    ///     }
+    ///     options: langid!("de").into(),
+    ///     metadata: Default::default(),
     /// };
     /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load_payload(&req_with_langid);
+    ///     provider.load_resource(&req_with_langid);
     /// assert!(matches!(response, Ok(_)));
     ///
     /// // Requests without a langid should fail:
     /// let req_no_langid = DataRequest {
-    ///     resource_path: ResourcePath {
-    ///         key: key::HELLO_WORLD_V1,
-    ///         options: Default::default(),
-    ///     }
+    ///     options: Default::default(),
+    ///     metadata: Default::default(),
     /// };
     /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load_payload(&req_no_langid);
+    ///     provider.load_resource(&req_no_langid);
     /// assert!(matches!(
     ///     response,
     ///     Err(DataError { kind: DataErrorKind::FilteredResource, .. })
@@ -214,7 +202,7 @@ where
                 if !(old_predicate)(request) {
                     return false;
                 }
-                request.resource_path.options.langid.is_some()
+                request.options.langid.is_some()
             }),
             filter_name: self.filter_name,
         }
diff --git a/provider/core/src/filter/mod.rs b/provider/core/src/filter/mod.rs
index 28b683093e4..ea9ca4c925f 100644
--- a/provider/core/src/filter/mod.rs
+++ b/provider/core/src/filter/mod.rs
@@ -65,19 +65,40 @@ where
     pub filter_name: &'static str,
 }
 
-impl<D, F, M> DataProvider<M> for RequestFilterDataProvider<D, F>
+impl<D, F, M> DynProvider<M> for RequestFilterDataProvider<D, F>
 where
     F: Fn(&DataRequest) -> bool,
     M: DataMarker,
-    D: DataProvider<M>,
+    D: DynProvider<M>,
 {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
+        if (self.predicate)(req) {
+            self.inner.load_payload(key, req)
+        } else {
+            Err(DataErrorKind::FilteredResource
+                .with_str_context(self.filter_name)
+                .with_req(key, req))
+        }
+    }
+}
+
+impl<D, F, M> ResourceProvider<M> for RequestFilterDataProvider<D, F>
+where
+    F: Fn(&DataRequest) -> bool,
+    M: ResourceMarker,
+    D: ResourceProvider<M>,
+{
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
         if (self.predicate)(req) {
-            self.inner.load_payload(req)
+            self.inner.load_resource(req)
         } else {
             Err(DataErrorKind::FilteredResource
                 .with_str_context(self.filter_name)
-                .with_req(req))
+                .with_req(M::KEY, req))
         }
     }
 }
@@ -87,13 +108,33 @@ where
     F: Fn(&DataRequest) -> bool,
     D: BufferProvider,
 {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        if (self.predicate)(req) {
+            self.inner.load_buffer(key, req)
+        } else {
+            Err(DataErrorKind::FilteredResource
+                .with_str_context(self.filter_name)
+                .with_req(key, req))
+        }
+    }
+}
+
+impl<D, F> AnyProvider for RequestFilterDataProvider<D, F>
+where
+    F: Fn(&DataRequest) -> bool,
+    D: AnyProvider,
+{
+    fn load_any(&self, key: ResourceKey, req: &DataRequest) -> Result<AnyResponse, DataError> {
         if (self.predicate)(req) {
-            self.inner.load_buffer(req)
+            self.inner.load_any(key, req)
         } else {
             Err(DataErrorKind::FilteredResource
                 .with_str_context(self.filter_name)
-                .with_req(req))
+                .with_req(key, req))
         }
     }
 }
@@ -108,17 +149,14 @@ where
         resc_key: &ResourceKey,
     ) -> Result<Box<dyn Iterator<Item = ResourceOptions> + '_>, DataError> {
         self.inner.supported_options_for_key(resc_key).map(|iter| {
-            let resc_key = *resc_key;
             // Use filter_map instead of filter to avoid cloning the options
             let filtered_iter = iter.filter_map(move |options| {
                 let request = DataRequest {
-                    resource_path: ResourcePath {
-                        key: resc_key,
-                        options,
-                    },
+                    options,
+                    metadata: Default::default(),
                 };
                 if (self.predicate)(&request) {
-                    Some(request.resource_path.options)
+                    Some(request.options)
                 } else {
                     None
                 }
diff --git a/provider/core/src/fork/by_key.rs b/provider/core/src/fork/by_key.rs
index 24b68c91f39..7024e6efd58 100644
--- a/provider/core/src/fork/by_key.rs
+++ b/provider/core/src/fork/by_key.rs
@@ -13,8 +13,9 @@ use alloc::vec::Vec;
 /// even if the request failed for other reasons (such as an unsupported language). Therefore,
 /// you should add child providers that support disjoint sets of keys.
 ///
-/// Note: It does not make sense to construct a forking [`DataProvider`], since that is
-/// type-specific. Instead, make a forking [`BufferProvider`].
+/// Note: A forking [`ResourceProvider`] does not make sense, since there is only one key that
+/// type can support. Instead, you can create a forking [`AnyProvider`], [`BufferProvider`],
+/// or [`DynProvider`].
 ///
 /// # Examples
 ///
@@ -29,8 +30,9 @@ use alloc::vec::Vec;
 ///
 /// struct DummyBufferProvider;
 /// impl BufferProvider for DummyBufferProvider {
-///     fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
-///         Err(DataErrorKind::MissingResourceKey.with_req(req))
+///     fn load_buffer(&self, key: ResourceKey, req: &DataRequest)
+///             -> Result<DataResponse<BufferMarker>, DataError> {
+///         Err(DataErrorKind::MissingResourceKey.with_req(key, req))
 ///     }
 /// }
 ///
@@ -42,14 +44,9 @@ use alloc::vec::Vec;
 /// let data_provider = forking_provider.as_deserializing();
 ///
 /// let german_hello_world: DataPayload<HelloWorldV1Marker> = data_provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("de")),
-///             }
-///         }
+///     .load_resource(&DataRequest {
+///         options: langid!("de").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect("Loading should succeed")
 ///     .take_payload()
@@ -80,18 +77,14 @@ use alloc::vec::Vec;
 ///         .filter_by_langid(|langid| langid.language == language!("de")),
 /// );
 ///
-/// let data_provider: &dyn DataProvider<HelloWorldV1Marker> = &forking_provider.as_deserializing();
+/// let data_provider: &dyn ResourceProvider<HelloWorldV1Marker> = &forking_provider
+///     .as_deserializing();
 ///
 /// // Chinese is the first provider, so this succeeds
-/// let chinese_hello_world: DataPayload<HelloWorldV1Marker> = data_provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("zh")),
-///             }
-///         }
+/// let chinese_hello_world = data_provider
+///     .load_resource(&DataRequest {
+///         options: langid!("zh").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect("Loading should succeed")
 ///     .take_payload()
@@ -101,37 +94,63 @@ use alloc::vec::Vec;
 ///
 /// // German is shadowed by Chinese, so this fails
 /// data_provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("de")),
-///             }
-///         }
+///     .load_resource(&DataRequest {
+///         options: langid!("de").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect_err("Should stop at the first provider, even though the second has data");
 /// # }
 /// ```
 pub struct ForkByKeyProvider<P0, P1>(pub P0, pub P1);
 
-impl<P0: BufferProvider, P1: BufferProvider> BufferProvider for ForkByKeyProvider<P0, P1> {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
-        let result = self.0.load_buffer(req);
+impl<P0, P1> BufferProvider for ForkByKeyProvider<P0, P1>
+where
+    P0: BufferProvider,
+    P1: BufferProvider,
+{
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        let result = self.0.load_buffer(key, req);
         if !DataError::result_is_err_missing_resource_key(&result) {
             return result;
         }
-        self.1.load_buffer(req)
+        self.1.load_buffer(key, req)
     }
 }
 
-impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for ForkByKeyProvider<P0, P1> {
-    fn load_any(&self, req: &DataRequest) -> Result<AnyResponse, DataError> {
-        let result = self.0.load_any(req);
+impl<P0, P1> AnyProvider for ForkByKeyProvider<P0, P1>
+where
+    P0: AnyProvider,
+    P1: AnyProvider,
+{
+    fn load_any(&self, key: ResourceKey, req: &DataRequest) -> Result<AnyResponse, DataError> {
+        let result = self.0.load_any(key, req);
         if !DataError::result_is_err_missing_resource_key(&result) {
             return result;
         }
-        self.1.load_any(req)
+        self.1.load_any(key, req)
+    }
+}
+
+impl<M, P0, P1> DynProvider<M> for ForkByKeyProvider<P0, P1>
+where
+    M: DataMarker,
+    P0: DynProvider<M>,
+    P1: DynProvider<M>,
+{
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
+        let result = self.0.load_payload(key, req);
+        if !DataError::result_is_err_missing_resource_key(&result) {
+            return result;
+        }
+        self.1.load_payload(key, req)
     }
 }
 
@@ -141,8 +160,9 @@ impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for ForkByKeyProvider<P0, P1>
 /// even if the request failed for other reasons (such as an unsupported language). Therefore,
 /// you should add child providers that support disjoint sets of keys.
 ///
-/// Note: It does not make sense to construct a forking [`DataProvider`], since that is
-/// type-specific. Instead, make a forking [`BufferProvider`].
+/// Note: A forking [`ResourceProvider`] does not make sense, since there is only one key that
+/// type can support. Instead, you can create a forking [`AnyProvider`], [`BufferProvider`],
+/// or [`DynProvider`].
 ///
 /// # Examples
 ///
@@ -167,18 +187,14 @@ impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for ForkByKeyProvider<P0, P1>
 ///     ]
 /// };
 ///
-/// let data_provider: &dyn DataProvider<HelloWorldV1Marker> = &forking_provider.as_deserializing();
+/// let data_provider: &dyn ResourceProvider<HelloWorldV1Marker> = &forking_provider
+///     .as_deserializing();
 ///
 /// // Chinese is the first provider, so this succeeds
-/// let chinese_hello_world: DataPayload<HelloWorldV1Marker> = data_provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("zh")),
-///             }
-///         }
+/// let chinese_hello_world = data_provider
+///     .load_resource(&DataRequest {
+///         options: langid!("zh").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect("Loading should succeed")
 ///     .take_payload()
@@ -188,14 +204,9 @@ impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for ForkByKeyProvider<P0, P1>
 ///
 /// // German is shadowed by Chinese, so this fails
 /// data_provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("de")),
-///             }
-///         }
+///     .load_resource(&DataRequest {
+///         options: langid!("de").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect_err("Should stop at the first provider, even though the second has data");
 /// # }
@@ -204,26 +215,56 @@ pub struct MultiForkByKeyProvider<P> {
     pub providers: Vec<P>,
 }
 
-impl<P: BufferProvider> BufferProvider for MultiForkByKeyProvider<P> {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
+impl<P> BufferProvider for MultiForkByKeyProvider<P>
+where
+    P: BufferProvider,
+{
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        for provider in self.providers.iter() {
+            let result = provider.load_buffer(key, req);
+            if !DataError::result_is_err_missing_resource_key(&result) {
+                return result;
+            }
+        }
+        Err(DataErrorKind::MissingResourceKey.with_key(key))
+    }
+}
+
+impl<P> AnyProvider for MultiForkByKeyProvider<P>
+where
+    P: AnyProvider,
+{
+    fn load_any(&self, key: ResourceKey, req: &DataRequest) -> Result<AnyResponse, DataError> {
         for provider in self.providers.iter() {
-            let result = provider.load_buffer(req);
+            let result = provider.load_any(key, req);
             if !DataError::result_is_err_missing_resource_key(&result) {
                 return result;
             }
         }
-        Err(DataErrorKind::MissingResourceKey.with_req(req))
+        Err(DataErrorKind::MissingResourceKey.with_key(key))
     }
 }
 
-impl<P: AnyProvider> AnyProvider for MultiForkByKeyProvider<P> {
-    fn load_any(&self, req: &DataRequest) -> Result<AnyResponse, DataError> {
+impl<M, P> DynProvider<M> for MultiForkByKeyProvider<P>
+where
+    M: DataMarker,
+    P: DynProvider<M>,
+{
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
         for provider in self.providers.iter() {
-            let result = provider.load_any(req);
+            let result = provider.load_payload(key, req);
             if !DataError::result_is_err_missing_resource_key(&result) {
                 return result;
             }
         }
-        Err(DataErrorKind::MissingResourceKey.with_req(req))
+        Err(DataErrorKind::MissingResourceKey.with_key(key))
     }
 }
diff --git a/provider/core/src/hello_world.rs b/provider/core/src/hello_world.rs
index 5fe926fcbc5..a1c7bf6695e 100644
--- a/provider/core/src/hello_world.rs
+++ b/provider/core/src/hello_world.rs
@@ -48,6 +48,10 @@ impl DataMarker for HelloWorldV1Marker {
     type Yokeable = HelloWorldV1<'static>;
 }
 
+impl ResourceMarker for HelloWorldV1Marker {
+    const KEY: ResourceKey = key::HELLO_WORLD_V1;
+}
+
 /// A data provider returning Hello World strings in different languages.
 ///
 /// Mostly useful for testing.
@@ -62,14 +66,9 @@ impl DataMarker for HelloWorldV1Marker {
 /// let provider = HelloWorldProvider::new_with_placeholder_data();
 ///
 /// let german_hello_world: DataPayload<HelloWorldV1Marker> = provider
-///     .load_payload(&DataRequest {
-///         resource_path: ResourcePath {
-///             key: key::HELLO_WORLD_V1,
-///             options: ResourceOptions {
-///                 variant: None,
-///                 langid: Some(langid!("de")),
-///             }
-///         }
+///     .load_resource(&DataRequest {
+///         options: langid!("de").into(),
+///         metadata: Default::default(),
 ///     })
 ///     .expect("Loading should succeed")
 ///     .take_payload()
@@ -123,18 +122,19 @@ impl HelloWorldProvider {
     }
 }
 
-impl DataProvider<HelloWorldV1Marker> for HelloWorldProvider {
-    fn load_payload(
+impl ResourceProvider<HelloWorldV1Marker> for HelloWorldProvider {
+    fn load_resource(
         &self,
         req: &DataRequest,
     ) -> Result<DataResponse<HelloWorldV1Marker>, DataError> {
-        key::HELLO_WORLD_V1.match_key(req.resource_path.key)?;
-        let langid = req.try_langid()?;
+        let langid = req
+            .get_langid()
+            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(HelloWorldV1Marker::KEY, req))?;
         let data = self
             .map
             .get(langid)
             .map(|s| HelloWorldV1 { message: s.clone() })
-            .ok_or_else(|| DataErrorKind::MissingLocale.with_req(req))?;
+            .ok_or_else(|| DataErrorKind::MissingLocale.with_key(HelloWorldV1Marker::KEY))?;
         let metadata = DataResponseMetadata {
             data_langid: Some(langid.clone()),
             ..Default::default()
@@ -146,20 +146,21 @@ impl DataProvider<HelloWorldV1Marker> for HelloWorldProvider {
     }
 }
 
-impl_dyn_provider!(HelloWorldProvider, {
-    _ => HelloWorldV1Marker,
-}, ANY);
+impl_dyn_provider!(HelloWorldProvider, [HelloWorldV1Marker,], ANY);
 
 #[cfg(feature = "serialize")]
-impl_dyn_provider!(HelloWorldProvider, {
-    _ => HelloWorldV1Marker,
-}, SERDE_SE);
+impl_dyn_provider!(HelloWorldProvider, [HelloWorldV1Marker,], SERDE_SE);
 
 pub struct HelloWorldJsonProvider(HelloWorldProvider);
 
 impl BufferProvider for HelloWorldJsonProvider {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
-        let result = self.0.load_payload(req)?;
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        key.match_key(key::HELLO_WORLD_V1)?;
+        let result = self.0.load_resource(req)?;
         let (mut metadata, old_payload) =
             DataResponse::<HelloWorldV1Marker>::take_metadata_and_payload(result)?;
         metadata.buffer_format = Some(BufferFormat::Json);
@@ -198,11 +199,14 @@ impl IterableProvider for HelloWorldProvider {
 impl crate::export::DataExporter<crate::any::AnyMarker> for HelloWorldProvider {
     fn put_payload(
         &mut self,
+        key: ResourceKey,
         req: DataRequest,
         payload: DataPayload<crate::any::AnyMarker>,
     ) -> Result<(), DataError> {
-        req.resource_path.key.match_key(key::HELLO_WORLD_V1)?;
-        let langid = req.try_langid()?;
+        key.match_key(key::HELLO_WORLD_V1)?;
+        let langid = req
+            .get_langid()
+            .ok_or_else(|| DataErrorKind::NeedsLocale.with_req(key, &req))?;
         let downcast_payload: DataPayload<HelloWorldV1Marker> = payload.downcast()?;
         self.map.insert(
             langid.clone(),
diff --git a/provider/core/src/inv.rs b/provider/core/src/inv.rs
index f8c2161f52b..05d7d75c5f4 100644
--- a/provider/core/src/inv.rs
+++ b/provider/core/src/inv.rs
@@ -26,7 +26,7 @@ use alloc::vec::Vec;
 ///
 /// let provider = InvariantDataProvider;
 /// let result: DataPayload<HelloWorldV1Marker> = provider
-///     .load_payload(&DataRequest::from(key::HELLO_WORLD_V1))
+///     .load_resource(&DataRequest::default())
 ///     .unwrap()
 ///     .take_payload()
 ///     .unwrap();
@@ -35,12 +35,25 @@ use alloc::vec::Vec;
 /// ```
 pub struct InvariantDataProvider;
 
-impl<M> DataProvider<M> for InvariantDataProvider
+impl<M> ResourceProvider<M> for InvariantDataProvider
+where
+    M: ResourceMarker,
+    M::Yokeable: Default,
+{
+    fn load_resource(&self, _: &DataRequest) -> Result<DataResponse<M>, DataError> {
+        Ok(DataResponse {
+            metadata: DataResponseMetadata::default(),
+            payload: Some(DataPayload::from_owned(M::Yokeable::default())),
+        })
+    }
+}
+
+impl<M> DynProvider<M> for InvariantDataProvider
 where
     M: DataMarker,
     M::Yokeable: Default,
 {
-    fn load_payload(&self, _req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+    fn load_payload(&self, _: ResourceKey, _: &DataRequest) -> Result<DataResponse<M>, DataError> {
         Ok(DataResponse {
             metadata: DataResponseMetadata::default(),
             payload: Some(DataPayload::from_owned(M::Yokeable::default())),
diff --git a/provider/core/src/iter.rs b/provider/core/src/iter.rs
index 3d154039e91..09f7c5a237d 100644
--- a/provider/core/src/iter.rs
+++ b/provider/core/src/iter.rs
@@ -2,14 +2,14 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-//! Collection of iteration APIs for [`DataProvider`].
+//! Collection of iteration APIs for data providers.
 
 use crate::prelude::*;
 use alloc::boxed::Box;
 
 /// A provider that can iterate over all supported [`ResourceOptions`] for a certain key.
 ///
-/// Implementing this trait means that a [`DataProvider`] knows all of the data it can successfully
+/// Implementing this trait means that a data provider knows all of the data it can successfully
 /// return from a load request.
 pub trait IterableProvider {
     /// Given a [`ResourceKey`], returns a boxed iterator over [`ResourceOptions`].
diff --git a/provider/core/src/lib.rs b/provider/core/src/lib.rs
index 10de4c44ad1..953a1ed14fa 100644
--- a/provider/core/src/lib.rs
+++ b/provider/core/src/lib.rs
@@ -4,91 +4,103 @@
 
 //! `icu_provider` is one of the [`ICU4X`] components.
 //!
-//! It defines traits and structs for transmitting data through the ICU4X locale data pipeline.
-//! The primary trait is [`DataProvider`]. It has one method, which transforms a [`Request`] into
-//! a [`Response`]:
+//! `icu_provider` defines traits and structs for transmitting data through the ICU4X locale
+//! data pipeline. The primary trait is [`ResourceProvider`]. It is parameterized by a
+//! [`ResourceMarker`], which contains the data type and a [`ResourceKey`]. It has one method,
+//! [`ResourceProvider::load_resource`], which transforms a [`DataRequest`]
+//! into a [`DataResponse`].
 //!
-//! ```ignore
-//! fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<'data>, DataError>
-//! ```
+//! - [`ResourceKey`] is a fixed identifier for the data type, such as `"plurals/cardinal@1"`.
+//! - [`DataRequest`] contains additional annotations to choose a specific variant of the key,
+//!   such as a locale.
+//! - [`DataResponse`] contains the data if the request was successful.
 //!
-//! A [`Request`] contains a [`ResourceKey`] (a fixed identifier such as "plurals/cardinal@1") and
-//! [`ResourceOptions`] (a language identifier and optional variant, e.g. "fr") being requested.
-//! The Response contains the data payload corresponding to the Request.
+//! In addition, there are three other traits which are widely implemented:
 //!
-//! A [`Response`] contains a [`DataPayload`] along with other metadata.
+//! - [`AnyProvider`] returns data as `dyn Any` trait objects.
+//! - [`BufferProvider`] returns data as `[u8]` buffers.
+//! - [`DynProvider`] returns structured data but is not specific to a key.
 //!
-//! The most common types required for ICU4X [`DataProvider`] are included via the prelude:
+//! The most common types required for this crate are included via the prelude:
 //!
 //! ```
 //! use icu_provider::prelude::*;
 //! ```
 //!
-//! ## Concrete Implementations of Data Providers
+//! ## Types of Data Providers
+//!
+//! All nontrivial data providers can fit into one of two classes.
+//!
+//! 1. Type 1: Those whose data originates as structured Rust objects
+//! 2. Type 2: Those whose data originates as unstructured `[u8]` buffers
+//!
+//! ### Type 1 Providers
+//!
+//! Type 1 providers generally implement [`AnyProvider`], which returns structured data cast into
+//! `dyn Any` trait objects. Users can call [`as_downcasting()`] to get an object implementing
+//! [`ResourceProvider`] by downcasting the trait objects.
+//!
+//! Examples of Type 1 providers:
+//!
+//! - [`CldrJsonDataProvider`] reads structured data from CLDR JSON source files and returns
+//!   structured Rust objects.
+//! - [`AnyPayloadProvider`] wraps a specific data struct and returns it.
+//! - The upcoming `crabbake` provider which reads structured data from Rust source files
+//!
+//! ### Type 2 Providers
+//!
+//! Type 2 providers generally implement [`BufferProvider`], which returns unstructured data
+//! typically represented as [`serde`]-serialized buffers. Users can call [`as_deserializing()`]
+//! to get an object implementing [`ResourceProvider`] by invoking Serde Deserialize.
+//!
+//! Examples of Type 2 providers:
 //!
-//! Any object implementing [`DataProvider`] can be used to supply ICU4X with locale data. ICU4X ships
-//! with some pre-built data providers:
+//! - [`FsDataProvider`] reads individual buffers from the filesystem.
+//! - [`BlobDataProvider`] reads buffers from a large in-memory blob.
 //!
-//! - [`CldrJsonDataProvider`](../icu_provider_cldr/transform/struct.CldrJsonDataProvider.html) reads structured
-//!   data directly from CLDR source files.
-//! - [`FsDataProvider`](../icu_provider_fs/struct.FsDataProvider.html) reads structured data from the
-//!   filesystem. It can also write out that filesystem structure. More efficient than CldrJsonDataProvider.
+//! ### Special-Purpose Providers
 //!
 //! This crate also contains some concrete implementations for testing purposes:
 //!
 //! - [`InvariantDataProvider`] returns fixed data that does not vary by locale.
-//! - [`AnyPayloadProvider`] wraps a particular instance of a struct and returns it.
 //! - [`HelloWorldProvider`] returns "hello world" strings in several languages.
 //!
+//! ## Combinatorial Providers
+//!
+//! ICU4X offers several built-in modules to combine providers in interesting ways:
+//!
+//! - Use the [`fork`] module to marshall data requests between multiple possible providers.
+//! - Use the [`either`] module to choose between multiple provider types at runtime.
+//! - Use the [`filter`] module to programmatically reject certain data requests.
+//!
 //! ## Types and Lifetimes
 //!
 //! Types compatible with [`Yokeable`] can be passed through the data provider, so long as they are
 //! associated with a marker type implementing [`DataMarker`].
 //!
-//! Most [`DataProvider`] traits take one lifetime argument: `'data`. This lifetime allows data
-//! structs to borrow zero-copy data. In practice, it also represents the lifetime of data that
-//! the Cart of the Yoke of the DataPayload borrows; for more information on carts and yokes,
-//! see [`yoke`].
+//! Data structs should generally have one lifetime argument: `'data`. This lifetime allows data
+//! structs to borrow zero-copy data.
 //!
 //! ## Additional Traits
 //!
 //! ### `IterableDataProvider`
 //!
-//! Data providers can implement [`IterableProvider`], allowing iteration over all [`ResourceOptions`]
-//! instances supported for a certain key in the data provider.
+//! Data providers can implement [`IterableProvider`], allowing iteration over all
+//! [`ResourceOptions`] instances supported for a certain key in the data provider.
 //!
 //! For more information, see the [`iter`] module.
 //!
-//! ### `BufferProvider`
-//!
-//! The trait [`BufferProvider`] represents a data provider that produces buffers (`[u8]`), which
-//! are typically deserialized later via Serde. This allows for a Serde-enabled provider
-//! to be saved as a trait object without being specific to a data struct type.
-//!
-//! ### `AnyProvider`
-//!
-//! The trait [`AnyProvider`] removes the type argument from [`DataProvider`] and requires
-//! that all data structs be convertible to the [`Any`](core::any::Any) type. This enables the
-//! processing of data without the caller knowing the underlying data struct.
-//!
-//! Since [`AnyProvider`] is not specific to a single type, it can be useful for caches or
-//! other bulk data operations.
-//!
 //! ### `DataProvider<SerializeMarker>`
 //!
 //! *Enabled with the "serialize" feature*
 //!
-//! Data providers capable of returning opaque `erased_serde::Serialize` trait objects can be used as
-//! input to a data exporter, such as when writing data to the filesystem.
-//!
-//! This trait is normally implemented using the [`impl_dyn_provider!`] macro.
+//! Data providers capable of returning opaque `erased_serde::Serialize` trait objects can be use
+//! as input to a data exporter, such as when writing data to the filesystem.
 //!
 //! This trait is normally implemented using the [`impl_dyn_provider!`] macro.
 //!
 //! [`ICU4X`]: ../icu/index.html
 //! [`DataProvider`]: data_provider::DataProvider
-//! [`Request`]: data_provider::DataRequest
-//! [`Response`]: data_provider::DataResponse
 //! [`ResourceKey`]: resource::ResourceKey
 //! [`ResourceOptions`]: resource::ResourceOptions
 //! [`IterableProvider`]: iter::IterableProvider
@@ -98,6 +110,11 @@
 //! [`AnyProvider`]: any::AnyProvider
 //! [`Yokeable`]: yoke::Yokeable
 //! [`impl_dyn_provider!`]: impl_dyn_provider
+//! [`as_downcasting()`]: AsDowncastingAnyProvider::as_downcasting
+//! [`as_deserializing()`]: AsDeserializingBufferProvider::as_deserializing
+//! [`CldrJsonDataProvider`]: ../icu_provider_cldr/struct.CldrJsonDataProvider.html
+//! [`FsDataProvider`]: ../icu_provider_fs/struct.FsDataProvider.html
+//! [`BlobDataProvider`]: ../icu_provider_blob/struct.BlobDataProvider.html
 
 #![cfg_attr(not(any(test, feature = "std")), no_std)]
 
@@ -130,7 +147,7 @@ pub mod struct_provider;
 pub use icu_provider_macros::data_struct;
 
 pub mod prelude {
-    //! Core selection of APIs and structures for [`DataProvider`].
+    //! Core selection of APIs and structures for the ICU4X data provider.
     pub use crate::any::AnyMarker;
     pub use crate::any::AnyPayload;
     pub use crate::any::AnyProvider;
@@ -138,21 +155,22 @@ pub mod prelude {
     pub use crate::buf::BufferMarker;
     pub use crate::buf::BufferProvider;
     pub use crate::data_provider::DataPayload;
-    pub use crate::data_provider::DataProvider;
     pub use crate::data_provider::DataRequest;
     pub use crate::data_provider::DataResponse;
     pub use crate::data_provider::DataResponseMetadata;
+    pub use crate::data_provider::DynProvider;
+    pub use crate::data_provider::ResourceProvider;
     pub use crate::error::DataError;
     pub use crate::error::DataErrorKind;
     pub use crate::marker::DataMarker;
+    pub use crate::marker::ResourceMarker;
     pub use crate::resource::ResourceKey;
     pub use crate::resource::ResourceKeyHash;
     pub use crate::resource::ResourceOptions;
-    pub use crate::resource::ResourcePath;
     pub use crate::resource_key;
 
-    pub use crate::any::AsDataProviderAnyMarkerWrap;
     pub use crate::any::AsDowncastingAnyProvider;
+    pub use crate::any::AsDynProviderAnyMarkerWrap;
     #[cfg(feature = "serde")]
     pub use crate::serde::AsDeserializingBufferProvider;
 }
diff --git a/provider/core/src/marker/mod.rs b/provider/core/src/marker/mod.rs
index fd4f8b33a5e..5adc976b15b 100644
--- a/provider/core/src/marker/mod.rs
+++ b/provider/core/src/marker/mod.rs
@@ -9,6 +9,7 @@ mod impls;
 pub use impls::*;
 
 use crate::yoke::Yokeable;
+use crate::ResourceKey;
 
 /// Trait marker for data structs. All types delivered by the data provider must be associated with
 /// something implementing this trait.
@@ -56,3 +57,7 @@ pub trait DataMarker {
     /// data struct.
     type Yokeable: for<'a> Yokeable<'a>;
 }
+
+pub trait ResourceMarker: DataMarker {
+    const KEY: ResourceKey;
+}
diff --git a/provider/core/src/resource.rs b/provider/core/src/resource.rs
index ccd14999035..ea57f8668d5 100644
--- a/provider/core/src/resource.rs
+++ b/provider/core/src/resource.rs
@@ -12,7 +12,7 @@ use core::default::Default;
 use core::fmt;
 use core::fmt::Write;
 use core::mem;
-use icu_locid::LanguageIdentifier;
+use icu_locid::{LanguageIdentifier, Locale};
 use writeable::{LengthHint, Writeable};
 use zerovec::ule::*;
 
@@ -363,8 +363,7 @@ impl Writeable for ResourceKey {
     }
 }
 
-/// A variant and language identifier, used for requesting data from a
-/// [`DataProvider`](crate::DataProvider).
+/// A variant and language identifier, used for requesting data from a data provider.
 ///
 /// The fields in a [`ResourceOptions`] are not generally known until runtime.
 #[derive(PartialEq, Clone, Default)]
@@ -429,6 +428,16 @@ impl From<LanguageIdentifier> for ResourceOptions {
     }
 }
 
+impl From<Locale> for ResourceOptions {
+    /// Create a ResourceOptions with the given language identifier and an empty variant field.
+    fn from(locale: Locale) -> Self {
+        Self {
+            langid: Some(locale.id),
+            variant: None,
+        }
+    }
+}
+
 impl ResourceOptions {
     /// Returns whether this [`ResourceOptions`] has all empty fields (no components).
     pub fn is_empty(&self) -> bool {
@@ -436,43 +445,6 @@ impl ResourceOptions {
     }
 }
 
-#[derive(Clone, PartialEq)]
-pub struct ResourcePath {
-    pub key: ResourceKey,
-    pub options: ResourceOptions,
-}
-
-impl fmt::Debug for ResourcePath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "ResourcePath{{{}}}", self)
-    }
-}
-
-impl fmt::Display for ResourcePath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeable::Writeable::write_to(self, f)
-    }
-}
-
-impl writeable::Writeable for ResourcePath {
-    fn write_to<W: core::fmt::Write + ?Sized>(&self, sink: &mut W) -> core::fmt::Result {
-        writeable::Writeable::write_to(&self.key, sink)?;
-        if !self.options.is_empty() {
-            sink.write_char('/')?;
-            writeable::Writeable::write_to(&self.options, sink)?;
-        }
-        Ok(())
-    }
-
-    fn write_len(&self) -> writeable::LengthHint {
-        let mut result = writeable::Writeable::write_len(&self.key);
-        if !self.options.is_empty() {
-            result += writeable::Writeable::write_len(&self.options) + 1;
-        }
-        result
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -546,25 +518,4 @@ mod tests {
             writeable::assert_writeable_eq!(&cas.resc_options, cas.expected);
         }
     }
-
-    #[test]
-    fn test_resource_path_to_string() {
-        for key_cas in get_key_test_cases().iter() {
-            for options_cas in get_options_test_cases().iter() {
-                let expected = if options_cas.resc_options.is_empty() {
-                    key_cas.expected.to_string()
-                } else {
-                    format!("{}/{}", key_cas.expected, options_cas.expected)
-                };
-                let resource_path = ResourcePath {
-                    key: key_cas.resc_key,
-                    // Note: once https://github.com/rust-lang/rust/pull/80470 is accepted,
-                    // we won't have to clone here.
-                    options: options_cas.resc_options.clone(),
-                };
-                assert_eq!(expected, resource_path.to_string());
-                writeable::assert_writeable_eq!(&resource_path, expected);
-            }
-        }
-    }
 }
diff --git a/provider/core/src/serde/de.rs b/provider/core/src/serde/de.rs
index 0ec35515716..81aeae02001 100644
--- a/provider/core/src/serde/de.rs
+++ b/provider/core/src/serde/de.rs
@@ -105,9 +105,9 @@ impl DataPayload<BufferMarker> {
     }
 }
 
-impl<P, M> DataProvider<M> for DeserializingBufferProvider<'_, P>
+impl<P, M> ResourceProvider<M> for DeserializingBufferProvider<'_, P>
 where
-    M: DataMarker,
+    M: ResourceMarker,
     P: BufferProvider + ?Sized,
     // Actual bound:
     //     for<'de> <M::Yokeable as Yokeable<'de>>::Output: Deserialize<'de>,
@@ -115,8 +115,26 @@ where
     for<'de> YokeTraitHack<<M::Yokeable as Yokeable<'de>>::Output>: Deserialize<'de>,
 {
     /// Converts a buffer into a concrete type by deserializing from a supported buffer format.
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
-        let old_response = BufferProvider::load_buffer(self.0, req)?;
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+        self.load_payload(M::KEY, req)
+    }
+}
+
+impl<P, M> DynProvider<M> for DeserializingBufferProvider<'_, P>
+where
+    M: DataMarker,
+    P: BufferProvider + ?Sized,
+    // Actual bound:
+    //     for<'de> <M::Yokeable as Yokeable<'de>>::Output: serde::de::Deserialize<'de>,
+    // Necessary workaround bound (see `yoke::trait_hack` docs):
+    for<'de> YokeTraitHack<<M::Yokeable as Yokeable<'de>>::Output>: Deserialize<'de>,
+{
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
+        let old_response = BufferProvider::load_buffer(self.0, key, req)?;
         if let Some(old_payload) = old_response.payload {
             let buffer_format = old_response
                 .metadata
diff --git a/provider/core/src/serde/mod.rs b/provider/core/src/serde/mod.rs
index 703dbe6f8e0..33405a01736 100644
--- a/provider/core/src/serde/mod.rs
+++ b/provider/core/src/serde/mod.rs
@@ -13,13 +13,13 @@
 //!
 //! ## Serializing
 //!
-//! Providers that have full type information should implement [`DataProvider`]`<`[`SerializeMarker`]`>`.
+//! Providers that have full type information should implement [`DynProvider`]`<`[`SerializeMarker`]`>`.
 //! Note that a provider like `FsDataProvider` cannot implement that trait, because type information
 //! on the data structs is required in order to deserialize and then serialize them.
 //!
-//! [`DataProvider`]`<`[`SerializeMarker`]`>` is used by data exporters such as `FilesystemExporter`.
+//! [`DynProvider`]`<`[`SerializeMarker`]`>` is used by data exporters such as `FilesystemExporter`.
 //!
-//! [`DataProvider`]: crate::data_provider::DataProvider
+//! [`DynProvider`]: crate::data_provider::DynProvider
 //! [`BufferProvider`]: crate::buf::BufferProvider
 
 pub mod borrow_de_utils;
diff --git a/provider/core/src/struct_provider.rs b/provider/core/src/struct_provider.rs
index c8ce55529ce..95ee97b00cb 100644
--- a/provider/core/src/struct_provider.rs
+++ b/provider/core/src/struct_provider.rs
@@ -28,7 +28,8 @@ use crate::prelude::*;
 ///     data: AnyPayload::from_static_ref(&CONST_DATA),
 /// };
 ///
-/// let payload: DataPayload<HelloWorldV1Marker> = provider.load_any(&DataRequest::from(SAMPLE_KEY))
+/// let payload: DataPayload<HelloWorldV1Marker> = provider
+///     .load_any(SAMPLE_KEY, &DataRequest::default())
 ///     .expect("Load should succeed")
 ///     .downcast()
 ///     .expect("Types should match")
@@ -43,8 +44,8 @@ pub struct AnyPayloadProvider {
 }
 
 impl AnyProvider for AnyPayloadProvider {
-    fn load_any(&self, req: &DataRequest) -> Result<AnyResponse, DataError> {
-        req.resource_path.key.match_key(self.key)?;
+    fn load_any(&self, key: ResourceKey, _: &DataRequest) -> Result<AnyResponse, DataError> {
+        key.match_key(self.key)?;
         Ok(AnyResponse {
             metadata: DataResponseMetadata::default(),
             payload: Some(self.data.clone()),
diff --git a/provider/fs/Cargo.toml b/provider/fs/Cargo.toml
index a6ec3eedaae..a600d815ba7 100644
--- a/provider/fs/Cargo.toml
+++ b/provider/fs/Cargo.toml
@@ -73,3 +73,4 @@ path = "src/lib.rs"
 [[bench]]
 name = "provider_fs"
 harness = false
+required-features = ["deserialize_json"]
diff --git a/provider/fs/benches/provider_fs.rs b/provider/fs/benches/provider_fs.rs
index 973f7c1d739..0891903bcbe 100644
--- a/provider/fs/benches/provider_fs.rs
+++ b/provider/fs/benches/provider_fs.rs
@@ -15,15 +15,10 @@ fn overview_bench(c: &mut Criterion) {
         b.iter(|| {
             let provider = FsDataProvider::try_new("./tests/testdata/json")
                 .expect("Loading file from testdata directory");
-            let _: DataPayload<PluralRulesV1Marker> = black_box(&provider)
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key: key::CARDINAL_V1,
-                        options: ResourceOptions {
-                            variant: None,
-                            langid: Some(langid!("ru")),
-                        },
-                    },
+            let _: DataPayload<CardinalV1Marker> = black_box(&provider)
+                .load_resource(&DataRequest {
+                    options: langid!("ru").into(),
+                    metadata: Default::default(),
                 })
                 .expect("The data should be valid")
                 .take_payload()
@@ -48,15 +43,10 @@ fn json_bench(c: &mut Criterion) {
 
     c.bench_function("json/generic", |b| {
         b.iter(|| {
-            let _: DataPayload<PluralRulesV1Marker> = black_box(&provider)
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key: key::CARDINAL_V1,
-                        options: ResourceOptions {
-                            variant: None,
-                            langid: Some(langid!("ru")),
-                        },
-                    },
+            let _: DataPayload<CardinalV1Marker> = black_box(&provider)
+                .load_resource(&DataRequest {
+                    options: langid!("ru").into(),
+                    metadata: Default::default(),
                 })
                 .expect("The data should be valid")
                 .take_payload()
@@ -66,16 +56,11 @@ fn json_bench(c: &mut Criterion) {
 
     c.bench_function("json/erased_serde", |b| {
         b.iter(|| {
-            let _: DataPayload<PluralRulesV1Marker> = black_box(&provider as &dyn BufferProvider)
+            let _: DataPayload<CardinalV1Marker> = black_box(&provider as &dyn BufferProvider)
                 .as_deserializing()
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key: key::CARDINAL_V1,
-                        options: ResourceOptions {
-                            variant: None,
-                            langid: Some(langid!("ru")),
-                        },
-                    },
+                .load_resource(&DataRequest {
+                    options: langid!("ru").into(),
+                    metadata: Default::default(),
                 })
                 .expect("The data should be valid")
                 .take_payload()
@@ -91,15 +76,10 @@ fn bincode_bench(c: &mut Criterion) {
 
     c.bench_function("bincode/generic", |b| {
         b.iter(|| {
-            let _: DataPayload<PluralRulesV1Marker> = black_box(&provider)
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key: key::CARDINAL_V1,
-                        options: ResourceOptions {
-                            variant: None,
-                            langid: Some(langid!("sr")),
-                        },
-                    },
+            let _: DataPayload<CardinalV1Marker> = black_box(&provider)
+                .load_resource(&DataRequest {
+                    options: langid!("sr").into(),
+                    metadata: Default::default(),
                 })
                 .expect("The data should be valid")
                 .take_payload()
@@ -109,16 +89,11 @@ fn bincode_bench(c: &mut Criterion) {
 
     c.bench_function("bincode/erased_serde", |b| {
         b.iter(|| {
-            let _: DataPayload<PluralRulesV1Marker> = black_box(&provider as &dyn BufferProvider)
+            let _: DataPayload<CardinalV1Marker> = black_box(&provider as &dyn BufferProvider)
                 .as_deserializing()
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key: key::CARDINAL_V1,
-                        options: ResourceOptions {
-                            variant: None,
-                            langid: Some(langid!("sr")),
-                        },
-                    },
+                .load_resource(&DataRequest {
+                    options: langid!("sr").into(),
+                    metadata: Default::default(),
                 })
                 .expect("The data should be valid")
                 .take_payload()
diff --git a/provider/fs/src/export/fs_exporter.rs b/provider/fs/src/export/fs_exporter.rs
index 79bed7c3d1b..18e0601a3be 100644
--- a/provider/fs/src/export/fs_exporter.rs
+++ b/provider/fs/src/export/fs_exporter.rs
@@ -70,11 +70,13 @@ impl Drop for FilesystemExporter {
 impl DataExporter<SerializeMarker> for FilesystemExporter {
     fn put_payload(
         &mut self,
+        key: ResourceKey,
         req: DataRequest,
         obj: DataPayload<SerializeMarker>,
     ) -> Result<(), DataError> {
         let mut path_buf = self.root.clone();
-        path_buf.push(&*req.resource_path.writeable_to_string());
+        path_buf.push(&*key.writeable_to_string());
+        path_buf.push(&*req.options.writeable_to_string());
         log::trace!("Writing: {}", req);
         self.write_to_path(path_buf, obj.get().deref())?;
         Ok(())
diff --git a/provider/fs/src/export/mod.rs b/provider/fs/src/export/mod.rs
index 07b09ed54ee..62d61eb8c7a 100644
--- a/provider/fs/src/export/mod.rs
+++ b/provider/fs/src/export/mod.rs
@@ -45,18 +45,13 @@
 //!
 //! // Read the key from the filesystem and ensure it is as expected
 //! let req = DataRequest {
-//!     resource_path: ResourcePath {
-//!         key: key::HELLO_WORLD_V1,
-//!         options: ResourceOptions {
-//!             variant: None,
-//!             langid: Some(langid!("bn")),
-//!         },
-//!     }
+//!     options: langid!("bn").into(),
+//!     metadata: Default::default(),
 //! };
 //! let source_response: DataResponse<HelloWorldV1Marker> =
-//!     source_provider.load_payload(&req).unwrap();
+//!     source_provider.load_resource(&req).unwrap();
 //! let fs_response: DataResponse<HelloWorldV1Marker> =
-//!     fs_provider.load_payload(&req).unwrap();
+//!     fs_provider.load_resource(&req).unwrap();
 //!
 //! assert_eq!(
 //!     source_response.payload.unwrap().get(),
diff --git a/provider/fs/src/fs_data_provider.rs b/provider/fs/src/fs_data_provider.rs
index e2332827fbc..02af2498651 100644
--- a/provider/fs/src/fs_data_provider.rs
+++ b/provider/fs/src/fs_data_provider.rs
@@ -60,29 +60,37 @@ impl FsDataProvider {
         })
     }
 
-    fn get_reader(&self, req: &DataRequest) -> Result<(impl Read, PathBuf), DataError> {
+    fn get_reader(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<(impl Read, PathBuf), DataError> {
         let mut path_buf = self.res_root.clone();
-        path_buf.push(&*req.resource_path.key.writeable_to_string());
-        if req.resource_path.options.is_empty() {
+        path_buf.push(&*key.writeable_to_string());
+        if req.options.is_empty() {
             path_buf.set_extension(self.manifest.get_file_extension());
         }
         if !path_buf.exists() {
-            return Err(DataErrorKind::MissingResourceKey.with_req(req));
+            return Err(DataErrorKind::MissingResourceKey.with_req(key, req));
         }
-        if !req.resource_path.options.is_empty() {
+        if !req.options.is_empty() {
             // TODO: Implement proper locale fallback
-            path_buf.push(&*req.resource_path.options.writeable_to_string());
+            path_buf.push(&*req.options.writeable_to_string());
             path_buf.set_extension(self.manifest.get_file_extension());
         }
         if !path_buf.exists() {
-            return Err(DataErrorKind::MissingResourceOptions.with_req(req));
+            return Err(DataErrorKind::MissingResourceOptions.with_req(key, req));
         }
         let file = File::open(&path_buf).map_err(|e| DataError::from(e).with_path(&path_buf))?;
         Ok((BufReader::new(file), path_buf))
     }
 
-    fn get_rc_buffer(&self, req: &DataRequest) -> Result<(Rc<[u8]>, PathBuf), DataError> {
-        let (mut reader, path_buf) = self.get_reader(req)?;
+    fn get_rc_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<(Rc<[u8]>, PathBuf), DataError> {
+        let (mut reader, path_buf) = self.get_reader(key, req)?;
         let mut buffer = Vec::<u8>::new();
         reader
             .read_to_end(&mut buffer)
@@ -93,8 +101,12 @@ impl FsDataProvider {
 }
 
 impl BufferProvider for FsDataProvider {
-    fn load_buffer(&self, req: &DataRequest) -> Result<DataResponse<BufferMarker>, DataError> {
-        let (rc_buffer, _) = self.get_rc_buffer(req)?;
+    fn load_buffer(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<BufferMarker>, DataError> {
+        let (rc_buffer, _) = self.get_rc_buffer(key, req)?;
         let mut metadata = DataResponseMetadata::default();
         // TODO(#1109): Set metadata.data_langid correctly.
         metadata.buffer_format = Some(self.manifest.buffer_format);
@@ -105,7 +117,20 @@ impl BufferProvider for FsDataProvider {
     }
 }
 
-impl<M> DataProvider<M> for FsDataProvider
+impl<M> ResourceProvider<M> for FsDataProvider
+where
+    M: ResourceMarker,
+    // Actual bound:
+    //     for<'de> <M::Yokeable as Yokeable<'de>>::Output: serde::de::Deserialize<'de>,
+    // Necessary workaround bound (see `yoke::trait_hack` docs):
+    for<'de> YokeTraitHack<<M::Yokeable as Yokeable<'de>>::Output>: serde::de::Deserialize<'de>,
+{
+    fn load_resource(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
+        self.as_deserializing().load_resource(req)
+    }
+}
+
+impl<M> DynProvider<M> for FsDataProvider
 where
     M: DataMarker,
     // Actual bound:
@@ -113,7 +138,11 @@ where
     // Necessary workaround bound (see `yoke::trait_hack` docs):
     for<'de> YokeTraitHack<<M::Yokeable as Yokeable<'de>>::Output>: serde::de::Deserialize<'de>,
 {
-    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<M>, DataError> {
-        self.as_deserializing().load_payload(req)
+    fn load_payload(
+        &self,
+        key: ResourceKey,
+        req: &DataRequest,
+    ) -> Result<DataResponse<M>, DataError> {
+        self.as_deserializing().load_payload(key, req)
     }
 }
diff --git a/provider/fs/tests/test_file_io.rs b/provider/fs/tests/test_file_io.rs
index fbe0c9a30df..5092e25cac9 100644
--- a/provider/fs/tests/test_file_io.rs
+++ b/provider/fs/tests/test_file_io.rs
@@ -56,19 +56,6 @@ const EXPECTED_SR_DATA: PluralRulesTestData = PluralRulesTestData {
     many: None,
 };
 
-#[allow(dead_code)]
-fn get_request(langid: LanguageIdentifier) -> DataRequest {
-    DataRequest {
-        resource_path: ResourcePath {
-            key: key::CARDINAL_V1,
-            options: ResourceOptions {
-                variant: None,
-                langid: Some(langid),
-            },
-        },
-    }
-}
-
 #[cfg(not(feature = "deserialize_json"))]
 #[test]
 fn test_json_feature() {
@@ -81,8 +68,11 @@ fn test_json() {
     let provider = FsDataProvider::try_new("./tests/testdata/json")
         .expect("Loading file from testdata directory");
 
-    let plurals_data: DataPayload<PluralRulesV1Marker> = provider
-        .load_payload(&get_request(langid!("ru")))
+    let plurals_data: DataPayload<CardinalV1Marker> = provider
+        .load_resource(&DataRequest {
+            options: langid!("ru").into(),
+            metadata: Default::default(),
+        })
         .expect("The data should be valid")
         .take_payload()
         .expect("The data should be present");
@@ -95,9 +85,12 @@ fn test_json_dyn_erased_serde() {
     let provider = FsDataProvider::try_new("./tests/testdata/json")
         .expect("Loading file from testdata directory");
 
-    let plurals_data: DataPayload<PluralRulesV1Marker> = (&provider as &dyn BufferProvider)
+    let plurals_data: DataPayload<CardinalV1Marker> = (&provider as &dyn BufferProvider)
         .as_deserializing()
-        .load_payload(&get_request(langid!("ru")))
+        .load_resource(&DataRequest {
+            options: langid!("ru").into(),
+            metadata: Default::default(),
+        })
         .expect("The data should be valid")
         .take_payload()
         .expect("The data should be present");
@@ -110,35 +103,26 @@ fn test_json_errors() {
     let provider = FsDataProvider::try_new("./tests/testdata/json")
         .expect("Loading file from testdata directory");
 
-    type Provider = dyn DataProvider<PluralRulesV1Marker>;
+    type CardinalProvider = dyn ResourceProvider<CardinalV1Marker>;
+    type OrdinalProvider = dyn ResourceProvider<OrdinalV1Marker>;
 
     assert!(matches!(
-        Provider::load_payload(
+        CardinalProvider::load_resource(
             &provider,
             &DataRequest {
-                resource_path: ResourcePath {
-                    key: key::CARDINAL_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("ru"))
-                    }
-                }
+                options: langid!("ru").into(),
+                metadata: Default::default(),
             },
         ),
         Ok(_)
     ));
 
     assert!(matches!(
-        Provider::load_payload(
+        CardinalProvider::load_resource(
             &provider,
             &DataRequest {
-                resource_path: ResourcePath {
-                    key: key::CARDINAL_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("zh"))
-                    }
-                }
+                options: langid!("zh").into(),
+                metadata: Default::default(),
             },
         ),
         Err(DataError {
@@ -148,16 +132,11 @@ fn test_json_errors() {
     ));
 
     assert!(matches!(
-        Provider::load_payload(
+        OrdinalProvider::load_resource(
             &provider,
             &DataRequest {
-                resource_path: ResourcePath {
-                    key: key::ORDINAL_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("ru"))
-                    }
-                }
+                options: langid!("ru").into(),
+                metadata: Default::default(),
             },
         ),
         Err(DataError {
@@ -167,16 +146,11 @@ fn test_json_errors() {
     ));
 
     assert!(matches!(
-        Provider::load_payload(
+        OrdinalProvider::load_resource(
             &provider,
             &DataRequest {
-                resource_path: ResourcePath {
-                    key: icu_provider::hello_world::key::HELLO_WORLD_V1,
-                    options: ResourceOptions {
-                        variant: None,
-                        langid: Some(langid!("ru"))
-                    }
-                }
+                options: langid!("ru").into(),
+                metadata: Default::default(),
             },
         ),
         Err(DataError {
@@ -192,8 +166,11 @@ fn test_bincode() {
     let provider = FsDataProvider::try_new("./tests/testdata/bincode")
         .expect("Loading file from testdata directory");
 
-    let plurals_data: DataPayload<PluralRulesV1Marker> = provider
-        .load_payload(&get_request(langid!("sr")))
+    let plurals_data: DataPayload<CardinalV1Marker> = provider
+        .load_resource(&DataRequest {
+            options: langid!("sr").into(),
+            metadata: Default::default(),
+        })
         .expect("The data should be valid")
         .take_payload()
         .expect("The data should be present");
@@ -206,9 +183,12 @@ fn test_bincode_dyn_erased_serde() {
     let provider = FsDataProvider::try_new("./tests/testdata/bincode")
         .expect("Loading file from testdata directory");
 
-    let plurals_data: DataPayload<PluralRulesV1Marker> = (&provider as &dyn BufferProvider)
+    let plurals_data: DataPayload<CardinalV1Marker> = (&provider as &dyn BufferProvider)
         .as_deserializing()
-        .load_payload(&get_request(langid!("sr")))
+        .load_resource(&DataRequest {
+            options: langid!("sr").into(),
+            metadata: Default::default(),
+        })
         .expect("The data should be valid")
         .take_payload()
         .expect("The data should be present");
diff --git a/provider/macros/Cargo.toml b/provider/macros/Cargo.toml
index dd1913c64bf..4f8dcd90488 100644
--- a/provider/macros/Cargo.toml
+++ b/provider/macros/Cargo.toml
@@ -31,3 +31,6 @@ proc-macro = true
 proc-macro2 = "1.0.27"
 quote = "1.0.9"
 syn = { version = "1.0.73", features = ["full"]}
+
+[dev-dependencies]
+icu_provider = { path = "../core", features = ["macros"] }
diff --git a/provider/macros/src/lib.rs b/provider/macros/src/lib.rs
index 74f0a76ce01..2e5d36787fc 100644
--- a/provider/macros/src/lib.rs
+++ b/provider/macros/src/lib.rs
@@ -4,11 +4,17 @@
 
 extern crate proc_macro;
 use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
+use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use syn::parse_macro_input;
 use syn::spanned::Spanned;
+use syn::AttributeArgs;
 use syn::ItemStruct;
+use syn::Meta;
+use syn::NestedMeta;
+
+#[cfg(test)]
+mod tests;
 
 #[proc_macro_attribute]
 /// The `#[data_struct]` attribute should be applied to all types intended
@@ -16,15 +22,40 @@ use syn::ItemStruct;
 ///
 /// - `Apply #[derive(Yokeable, ZeroCopyFrom)]`. The `ZeroCopyFrom` derive can
 ///    be customized with `#[yoke(cloning_zcf)]` as needed
-/// - Create a `FooMarker` struct for the type
-/// - Implement `icu_provider::DataMarker` for `FooMarker`
-pub fn data_struct(_attr: TokenStream, item: TokenStream) -> TokenStream {
+///
+/// In addition, the attribute can be used to implement `DataMarker` and/or `ResourceMarker`
+/// by adding symbols with optional key strings:
+///
+/// ```
+/// use icu_provider::prelude::*;
+/// use std::borrow::Cow;
+///
+/// // We also need `yoke` in scope: [icu4x#1557](https://github.com/unicode-org/icu4x/issues/1557)
+/// use icu_provider::yoke;
+///
+/// #[icu_provider::data_struct(
+///     FooV1Marker,
+///     BarV1Marker = "demo/bar@1",
+///     BazV1Marker = "demo/baz@1"
+/// )]
+/// pub struct FooV1<'data> {
+///     message: Cow<'data, str>,
+/// };
+///
+/// // Note: FooV1Marker implements `DataMarker` but not `ResourceMarker`.
+/// // The other two implement `ResourceMarker`.
+///
+/// assert_eq!(BarV1Marker::KEY.get_path(), "demo/bar@1");
+/// assert_eq!(BazV1Marker::KEY.get_path(), "demo/baz@1");
+/// ```
+pub fn data_struct(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr as AttributeArgs);
     let item = parse_macro_input!(item as ItemStruct);
 
-    TokenStream::from(data_struct_impl(item))
+    TokenStream::from(data_struct_impl(attr, item))
 }
 
-fn data_struct_impl(item: ItemStruct) -> TokenStream2 {
+fn data_struct_impl(attr: AttributeArgs, item: ItemStruct) -> TokenStream2 {
     if item.generics.type_params().count() > 0 {
         return syn::Error::new(
             item.generics.span(),
@@ -35,7 +66,12 @@ fn data_struct_impl(item: ItemStruct) -> TokenStream2 {
     let lifetimes = item.generics.lifetimes().collect::<Vec<_>>();
 
     let name = &item.ident;
-    let marker = Ident::new(&format!("{}Marker", name), Span::call_site());
+
+    let name_with_lt = if lifetimes.get(0).is_some() {
+        quote!(#name<'static>)
+    } else {
+        quote!(#name)
+    };
 
     if lifetimes.len() > 1 {
         return syn::Error::new(
@@ -45,31 +81,49 @@ fn data_struct_impl(item: ItemStruct) -> TokenStream2 {
         .to_compile_error();
     }
 
-    let docs = format!("Marker type for [`{}`]", name);
-
-    if lifetimes.get(0).is_some() {
-        quote!(
-            #[doc = #docs]
-            pub struct #marker;
+    let mut result = TokenStream2::new();
 
-            impl icu_provider::DataMarker for #marker {
-                type Yokeable = #name<'static>;
+    for single_attr in attr.into_iter() {
+        match single_attr {
+            NestedMeta::Meta(Meta::NameValue(name_value)) => {
+                let marker_name = &name_value.path;
+                let key_lit = &name_value.lit;
+                let key_str = match key_lit {
+                    syn::Lit::Str(lit_str) => lit_str.value(),
+                    _ => panic!("Key must be a string"),
+                };
+                let docs = format!("Marker type for [`{}`]: \"{}\"", name, key_str);
+                result.extend(quote!(
+                    #[doc = #docs]
+                    pub struct #marker_name;
+                    impl icu_provider::DataMarker for #marker_name {
+                        type Yokeable = #name_with_lt;
+                    }
+                    impl icu_provider::ResourceMarker for #marker_name {
+                        const KEY: icu_provider::ResourceKey = icu_provider::resource_key!(#key_lit);
+                    }
+                ));
             }
-
-            #[derive(Yokeable, ZeroCopyFrom)]
-            #item
-        )
-    } else {
-        quote!(
-            #[doc = #docs]
-            pub struct #marker;
-
-            impl icu_provider::DataMarker for #marker {
-                type Yokeable = #name;
+            NestedMeta::Meta(Meta::Path(marker_name)) => {
+                let docs = format!("Marker type for [`{}`]", name);
+                result.extend(quote!(
+                    #[doc = #docs]
+                    pub struct #marker_name;
+                    impl icu_provider::DataMarker for #marker_name {
+                        type Yokeable = #name_with_lt;
+                    }
+                ));
             }
-
-            #[derive(Yokeable, ZeroCopyFrom)]
-            #item
-        )
+            _ => {
+                panic!("Invalid attribute to #[data_struct]")
+            }
+        }
     }
+
+    result.extend(quote!(
+        #[derive(yoke::Yokeable, yoke::ZeroCopyFrom)]
+        #item
+    ));
+
+    result
 }
diff --git a/provider/macros/src/tests.rs b/provider/macros/src/tests.rs
new file mode 100644
index 00000000000..894af732106
--- /dev/null
+++ b/provider/macros/src/tests.rs
@@ -0,0 +1,117 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::data_struct_impl;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::NestedMeta;
+
+fn check(attr: Vec<TokenStream2>, item: TokenStream2, expected: TokenStream2) {
+    let actual = data_struct_impl(
+        attr.into_iter()
+            .map(syn::parse2)
+            .collect::<syn::parse::Result<Vec<NestedMeta>>>()
+            .unwrap(),
+        syn::parse2(item).unwrap(),
+    );
+    assert_eq!(expected.to_string(), actual.to_string());
+}
+
+#[test]
+fn test_basic() {
+    // #[data_struct]
+    check(
+        vec![],
+        quote!(
+            pub struct FooV1;
+        ),
+        quote!(
+            #[derive(yoke::Yokeable, yoke::ZeroCopyFrom)]
+            pub struct FooV1;
+        ),
+    );
+}
+
+#[test]
+fn test_data_marker() {
+    // #[data_struct(FooV1Marker)]
+    check(
+        vec![quote!(FooV1Marker)],
+        quote!(
+            pub struct FooV1;
+        ),
+        quote!(
+            #[doc = "Marker type for [`FooV1`]"]
+            pub struct FooV1Marker;
+            impl icu_provider::DataMarker for FooV1Marker {
+                type Yokeable = FooV1;
+            }
+            #[derive(yoke::Yokeable, yoke::ZeroCopyFrom)]
+            pub struct FooV1;
+        ),
+    );
+}
+
+#[test]
+fn test_resource_marker() {
+    // #[data_struct(BarV1Marker = "demo/bar@1")]
+    check(
+        vec![quote!(BarV1Marker = "demo/bar@1")],
+        quote!(
+            pub struct FooV1;
+        ),
+        quote!(
+            #[doc = "Marker type for [`FooV1`]: \"demo/bar@1\""]
+            pub struct BarV1Marker;
+            impl icu_provider::DataMarker for BarV1Marker {
+                type Yokeable = FooV1;
+            }
+            impl icu_provider::ResourceMarker for BarV1Marker {
+                const KEY: icu_provider::ResourceKey = icu_provider::resource_key!("demo/bar@1");
+            }
+            #[derive(yoke::Yokeable, yoke::ZeroCopyFrom)]
+            pub struct FooV1;
+        ),
+    );
+}
+
+#[test]
+fn test_multi_named_resource_marker() {
+    // #[data_struct(FooV1Marker, BarV1Marker = "demo/bar@1", BazV1Marker = "demo/baz@1")]
+    check(
+        vec![
+            quote!(FooV1Marker),
+            quote!(BarV1Marker = "demo/bar@1"),
+            quote!(BazV1Marker = "demo/baz@1"),
+        ],
+        quote!(
+            pub struct FooV1<'data>;
+        ),
+        quote!(
+            #[doc = "Marker type for [`FooV1`]"]
+            pub struct FooV1Marker;
+            impl icu_provider::DataMarker for FooV1Marker {
+                type Yokeable = FooV1<'static>;
+            }
+            #[doc = "Marker type for [`FooV1`]: \"demo/bar@1\""]
+            pub struct BarV1Marker;
+            impl icu_provider::DataMarker for BarV1Marker {
+                type Yokeable = FooV1<'static>;
+            }
+            impl icu_provider::ResourceMarker for BarV1Marker {
+                const KEY: icu_provider::ResourceKey = icu_provider::resource_key!("demo/bar@1");
+            }
+            #[doc = "Marker type for [`FooV1`]: \"demo/baz@1\""]
+            pub struct BazV1Marker;
+            impl icu_provider::DataMarker for BazV1Marker {
+                type Yokeable = FooV1<'static>;
+            }
+            impl icu_provider::ResourceMarker for BazV1Marker {
+                const KEY: icu_provider::ResourceKey = icu_provider::resource_key!("demo/baz@1");
+            }
+            #[derive(yoke::Yokeable, yoke::ZeroCopyFrom)]
+            pub struct FooV1<'data>;
+        ),
+    );
+}
diff --git a/provider/testdata/README.md b/provider/testdata/README.md
index 8efc5ab5dc0..0c71ec2a162 100644
--- a/provider/testdata/README.md
+++ b/provider/testdata/README.md
@@ -44,15 +44,10 @@ use icu_locid_macros::langid;
 
 let data_provider = icu_testdata::get_provider();
 
-let data: DataPayload<icu_plurals::provider::PluralRulesV1Marker> = data_provider
-    .load_payload(&DataRequest {
-        resource_path: ResourcePath {
-            key: icu_plurals::provider::key::CARDINAL_V1,
-            options: ResourceOptions {
-                langid: Some(langid!("ru")),
-                variant: None,
-            },
-        },
+let data: DataPayload<icu_plurals::provider::CardinalV1Marker> = data_provider
+    .load_resource(&DataRequest {
+        options: langid!("ru").into(),
+        metadata: Default::default(),
     })
     .unwrap()
     .take_payload()
diff --git a/provider/testdata/src/lib.rs b/provider/testdata/src/lib.rs
index 4bceae337ec..408780f5ce5 100644
--- a/provider/testdata/src/lib.rs
+++ b/provider/testdata/src/lib.rs
@@ -46,15 +46,10 @@
 //!
 //! let data_provider = icu_testdata::get_provider();
 //!
-//! let data: DataPayload<icu_plurals::provider::PluralRulesV1Marker> = data_provider
-//!     .load_payload(&DataRequest {
-//!         resource_path: ResourcePath {
-//!             key: icu_plurals::provider::key::CARDINAL_V1,
-//!             options: ResourceOptions {
-//!                 langid: Some(langid!("ru")),
-//!                 variant: None,
-//!             },
-//!         },
+//! let data: DataPayload<icu_plurals::provider::CardinalV1Marker> = data_provider
+//!     .load_resource(&DataRequest {
+//!         options: langid!("ru").into(),
+//!         metadata: Default::default(),
 //!     })
 //!     .unwrap()
 //!     .take_payload()
diff --git a/provider/uprops/README.md b/provider/uprops/README.md
index 08a3d77feec..876f76b796e 100644
--- a/provider/uprops/README.md
+++ b/provider/uprops/README.md
@@ -1,7 +1,7 @@
 # icu_provider_uprops [![crates.io](https://img.shields.io/crates/v/icu_provider_uprops)](https://crates.io/crates/icu_provider_uprops)
 
 `icu_provider_uprops` contains implementations of the [`ICU4X`]
-[`DataProvider`] interface backed by TOML files exported by the
+[data provider] interface backed by TOML files exported by the
 ICU4C icuwriteuprops tool. Create a directory containing TOML files for
 the necessary Unicode properties and then pass the path into the
 [`PropertiesDataProvider`].
@@ -11,7 +11,7 @@ for production use.  It is much more efficient if you use
 [`FsDataProvider`] or [`StaticDataProvider`] instead.
 
 [`ICU4X`]: ../icu/index.html
-[`DataProvider`]: icu_provider::prelude::DataProvider
+[data provider]: icu_provider
 [`FsDataProvider`]: ../icu_provider_fs/struct.FsDataProvider.html
 [`StaticDataProvider`]: ../icu_provider_blob/struct.StaticDataProvider.html
 
diff --git a/provider/uprops/src/bin_uniset.rs b/provider/uprops/src/bin_uniset.rs
index e69b54be03a..7f6dc3db64f 100644
--- a/provider/uprops/src/bin_uniset.rs
+++ b/provider/uprops/src/bin_uniset.rs
@@ -23,15 +23,16 @@ impl BinaryPropertyUnicodeSetDataProvider {
     }
 }
 
-impl DataProvider<UnicodePropertyV1Marker> for BinaryPropertyUnicodeSetDataProvider {
+impl DynProvider<UnicodePropertyV1Marker> for BinaryPropertyUnicodeSetDataProvider {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<UnicodePropertyV1Marker>, DataError> {
         let data = &self
             .data
-            .get(get_last_component_no_version(&req.resource_path.key))
-            .ok_or_else(|| DataErrorKind::MissingResourceKey.with_req(req))?;
+            .get(get_last_component_no_version(&key))
+            .ok_or_else(|| DataErrorKind::MissingResourceKey.with_req(key, req))?;
 
         let mut builder = UnicodeSetBuilder::new();
         for (start, end) in &data.ranges {
@@ -73,12 +74,7 @@ fn test_basic() {
         .expect("TOML should load successfully");
 
     let payload: DataPayload<UnicodePropertyV1Marker> = provider
-        .load_payload(&DataRequest {
-            resource_path: ResourcePath {
-                key: key::WHITE_SPACE_V1,
-                options: ResourceOptions::default(),
-            },
-        })
+        .load_payload(key::WHITE_SPACE_V1, &DataRequest::default())
         .expect("The data should be valid")
         .take_payload()
         .expect("Loading was successful");
diff --git a/provider/uprops/src/enum_codepointtrie.rs b/provider/uprops/src/enum_codepointtrie.rs
index dcbc0b11bb7..8041b077818 100644
--- a/provider/uprops/src/enum_codepointtrie.rs
+++ b/provider/uprops/src/enum_codepointtrie.rs
@@ -92,21 +92,22 @@ impl<T: TrieValue> TryFrom<&EnumeratedPropertyCodePointTrie> for UnicodeProperty
 }
 
 // implement data provider
-impl<T: TrieValue> DataProvider<UnicodePropertyMapV1Marker<T>>
+impl<T: TrieValue> DynProvider<UnicodePropertyMapV1Marker<T>>
     for EnumeratedPropertyCodePointTrieProvider
 {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<UnicodePropertyMapV1Marker<T>>, DataError> {
         // For data resource keys that represent the CodePointTrie data for an enumerated
         // property, the ResourceKey sub-category string will just be the short alias
         // for the property.
-        let prop_name = get_last_component_no_version(&req.resource_path.key);
+        let prop_name = get_last_component_no_version(&key);
         let source_cpt_data = &self
             .data
             .get(prop_name)
-            .ok_or_else(|| DataErrorKind::MissingResourceKey.with_req(req))?
+            .ok_or_else(|| DataErrorKind::MissingResourceKey.with_req(key, req))?
             .code_point_trie;
 
         let data_struct = UnicodePropertyMapV1::<T>::try_from(source_cpt_data)?;
@@ -157,12 +158,7 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<UnicodePropertyMapV1Marker<GeneralCategory>> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::GENERAL_CATEGORY_V1,
-                    options: ResourceOptions::default(),
-                },
-            })
+            .load_payload(key::GENERAL_CATEGORY_V1, &DataRequest::default())
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
@@ -180,12 +176,7 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<UnicodePropertyMapV1Marker<Script>> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::SCRIPT_V1,
-                    options: ResourceOptions::default(),
-                },
-            })
+            .load_payload(key::SCRIPT_V1, &DataRequest::default())
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
diff --git a/provider/uprops/src/enum_uniset.rs b/provider/uprops/src/enum_uniset.rs
index 0ca64f5f4dd..13d54ee7d97 100644
--- a/provider/uprops/src/enum_uniset.rs
+++ b/provider/uprops/src/enum_uniset.rs
@@ -56,19 +56,20 @@ fn expand_groupings<'a>(prop_name: &str, prop_val: &'a str) -> Vec<&'a str> {
     }
 }
 
-impl DataProvider<UnicodePropertyV1Marker> for EnumeratedPropertyUnicodeSetDataProvider {
+impl DynProvider<UnicodePropertyV1Marker> for EnumeratedPropertyUnicodeSetDataProvider {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<UnicodePropertyV1Marker>, DataError> {
-        let key = get_last_component_no_version(&req.resource_path.key);
+        let key_str = get_last_component_no_version(&key);
 
         // ResourceKey subcategory strings for enumerated properties are
         // of the form "name=value", using the short name for both.
         let (prop_name, prop_value) = {
-            let parts = key.split('=').collect::<Vec<_>>();
+            let parts = key_str.split('=').collect::<Vec<_>>();
             if parts.len() != 2 {
-                return Err(DataErrorKind::MissingResourceKey.with_req(req));
+                return Err(DataErrorKind::MissingResourceKey.with_req(key, req));
             }
             (parts[0], parts[1])
         };
@@ -76,7 +77,7 @@ impl DataProvider<UnicodePropertyV1Marker> for EnumeratedPropertyUnicodeSetDataP
         let toml_data = &self
             .data
             .get(prop_name)
-            .ok_or_else(|| DataErrorKind::MissingResourceKey.with_req(req))?;
+            .ok_or_else(|| DataErrorKind::MissingResourceKey.with_req(key, req))?;
 
         let valid_names = expand_groupings(prop_name, prop_value);
 
@@ -126,12 +127,13 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<UnicodePropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::GENERAL_CATEGORY_NUMBER_V1,
+            .load_payload(
+                key::GENERAL_CATEGORY_NUMBER_V1,
+                &DataRequest {
                     options: ResourceOptions::default(),
+                    metadata: Default::default(),
                 },
-            })
+            )
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
@@ -155,12 +157,7 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<UnicodePropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::SCRIPT_THAI_V1,
-                    options: ResourceOptions::default(),
-                },
-            })
+            .load_payload(key::SCRIPT_THAI_V1, &Default::default())
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
@@ -184,12 +181,7 @@ mod tests {
             let provider = EnumeratedPropertyUnicodeSetDataProvider::try_new(&root_dir)
                 .expect("TOML should load successfully");
             let payload: DataPayload<UnicodePropertyV1Marker> = provider
-                .load_payload(&DataRequest {
-                    resource_path: ResourcePath {
-                        key,
-                        options: ResourceOptions::default(),
-                    },
-                })
+                .load_payload(key, &DataRequest::default())
                 .expect("The data should be valid")
                 .take_payload()
                 .expect("Loading was successful");
@@ -298,12 +290,7 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<UnicodePropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::GENERAL_CATEGORY_SURROGATE_V1,
-                    options: ResourceOptions::default(),
-                },
-            })
+            .load_payload(key::GENERAL_CATEGORY_SURROGATE_V1, &DataRequest::default())
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
diff --git a/provider/uprops/src/lib.rs b/provider/uprops/src/lib.rs
index 347387c33e4..bab003b42cd 100644
--- a/provider/uprops/src/lib.rs
+++ b/provider/uprops/src/lib.rs
@@ -3,7 +3,7 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 //! `icu_provider_uprops` contains implementations of the [`ICU4X`]
-//! [`DataProvider`] interface backed by TOML files exported by the
+//! [data provider] interface backed by TOML files exported by the
 //! ICU4C icuwriteuprops tool. Create a directory containing TOML files for
 //! the necessary Unicode properties and then pass the path into the
 //! [`PropertiesDataProvider`].
@@ -13,7 +13,7 @@
 //! [`FsDataProvider`] or [`StaticDataProvider`] instead.
 //!
 //! [`ICU4X`]: ../icu/index.html
-//! [`DataProvider`]: icu_provider::prelude::DataProvider
+//! [data provider]: icu_provider
 //! [`FsDataProvider`]: ../icu_provider_fs/struct.FsDataProvider.html
 //! [`StaticDataProvider`]: ../icu_provider_blob/struct.StaticDataProvider.html
 
diff --git a/provider/uprops/src/provider.rs b/provider/uprops/src/provider.rs
index 2e1fdc4b61b..9899c94a848 100644
--- a/provider/uprops/src/provider.rs
+++ b/provider/uprops/src/provider.rs
@@ -30,15 +30,16 @@ impl PropertiesDataProvider {
     }
 }
 
-impl DataProvider<UnicodePropertyV1Marker> for PropertiesDataProvider {
+impl DynProvider<UnicodePropertyV1Marker> for PropertiesDataProvider {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<UnicodePropertyV1Marker>, DataError> {
-        if get_last_component_no_version(&req.resource_path.key).contains('=') {
-            self.enumerated.load_payload(req)
+        if get_last_component_no_version(&key).contains('=') {
+            self.enumerated.load_payload(key, req)
         } else {
-            self.binary.load_payload(req)
+            self.binary.load_payload(key, req)
         }
     }
 }
diff --git a/provider/uprops/src/script.rs b/provider/uprops/src/script.rs
index 3389e85787a..06e25f3f260 100644
--- a/provider/uprops/src/script.rs
+++ b/provider/uprops/src/script.rs
@@ -76,13 +76,14 @@ impl TryFrom<&ScriptExtensionsProperty> for ScriptExtensionsPropertyV1<'static>
 }
 
 // implement data provider
-impl DataProvider<ScriptExtensionsPropertyV1Marker> for ScriptExtensionsPropertyProvider {
+impl DynProvider<ScriptExtensionsPropertyV1Marker> for ScriptExtensionsPropertyProvider {
     fn load_payload(
         &self,
+        key: ResourceKey,
         req: &DataRequest,
     ) -> Result<DataResponse<ScriptExtensionsPropertyV1Marker>, DataError> {
-        if uprops_helpers::get_last_component_no_version(&req.resource_path.key) != "scx" {
-            return Err(DataErrorKind::MissingResourceKey.with_req(req));
+        if uprops_helpers::get_last_component_no_version(&key) != "scx" {
+            return Err(DataErrorKind::MissingResourceKey.with_req(key, req));
         }
 
         let source_scx_data = &self.data;
@@ -122,12 +123,13 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<ScriptExtensionsPropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::SCRIPT_EXTENSIONS_V1,
+            .load_payload(
+                key::SCRIPT_EXTENSIONS_V1,
+                &DataRequest {
                     options: ResourceOptions::default(),
+                    metadata: Default::default(),
                 },
-            })
+            )
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
@@ -151,12 +153,13 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<ScriptExtensionsPropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::SCRIPT_EXTENSIONS_V1,
+            .load_payload(
+                key::SCRIPT_EXTENSIONS_V1,
+                &DataRequest {
                     options: ResourceOptions::default(),
+                    metadata: Default::default(),
                 },
-            })
+            )
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
@@ -202,12 +205,7 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<ScriptExtensionsPropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::SCRIPT_EXTENSIONS_V1,
-                    options: ResourceOptions::default(),
-                },
-            })
+            .load_payload(key::SCRIPT_EXTENSIONS_V1, &DataRequest::default())
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");
@@ -288,12 +286,7 @@ mod tests {
             .expect("TOML should load successfully");
 
         let payload: DataPayload<ScriptExtensionsPropertyV1Marker> = provider
-            .load_payload(&DataRequest {
-                resource_path: ResourcePath {
-                    key: key::SCRIPT_EXTENSIONS_V1,
-                    options: ResourceOptions::default(),
-                },
-            })
+            .load_payload(key::SCRIPT_EXTENSIONS_V1, &DataRequest::default())
             .expect("The data should be valid")
             .take_payload()
             .expect("Loading was successful");