diff --git a/aya-ebpf-macros/src/map.rs b/aya-ebpf-macros/src/map.rs
index a5a2f22e3..7402d9b0f 100644
--- a/aya-ebpf-macros/src/map.rs
+++ b/aya-ebpf-macros/src/map.rs
@@ -1,13 +1,14 @@
 use std::borrow::Cow;
 
 use proc_macro2::TokenStream;
-use quote::quote;
+use quote::{format_ident, quote};
 use syn::{ItemStatic, Result};
 
 use crate::args::Args;
 pub(crate) struct Map {
     item: ItemStatic,
     name: String,
+    inner: Option<String>,
 }
 
 impl Map {
@@ -15,18 +16,48 @@ impl Map {
         let item: ItemStatic = syn::parse2(item)?;
         let mut args: Args = syn::parse2(attrs)?;
         let name = args.pop_name().unwrap_or_else(|| item.ident.to_string());
+        let inner = args.pop_string("inner");
         args.into_error()?;
-        Ok(Self { item, name })
+        Ok(Self { item, name, inner })
     }
 
     pub(crate) fn expand(&self) -> TokenStream {
         let section_name: Cow<'_, _> = "maps".into();
         let name = &self.name;
         let item = &self.item;
+
+        // Aya-specific mechanism for inner map bindings (legacy, NOT libbpf-compatible).
+        //
+        // Unlike libbpf which uses BTF relocations within the `.maps` section
+        // (see https://patchwork.ozlabs.org/comment/2418417/), this legacy `#[map]` macro
+        // uses a separate `.maps.inner` section containing null-terminated string pairs.
+        //
+        // This approach was chosen because the legacy map system doesn't require BTF.
+        // However, this mechanism is NOT compatible with libbpf loaders.
+        //
+        // For libbpf compatibility, use `#[btf_map]` with `aya_ebpf::btf_maps::{ArrayOfMaps, HashOfMaps}`
+        // which use BTF relocations that both aya and libbpf can process.
+        //
+        // Format: "outer_name\0inner_name\0" pairs, parsed by aya-obj.
+        let inner_binding = self.inner.as_ref().map(|inner| {
+            let binding_ident = format_ident!("__inner_map_binding_{}", name);
+            let binding_value = format!("{name}\0{inner}\0");
+            let binding_len = binding_value.len();
+            let binding_bytes = binding_value.as_bytes();
+            quote! {
+                #[unsafe(link_section = ".maps.inner")]
+                #[used]
+                #[allow(non_upper_case_globals)]
+                static #binding_ident: [u8; #binding_len] = [#(#binding_bytes),*];
+            }
+        });
+
         quote! {
             #[unsafe(link_section = #section_name)]
             #[unsafe(export_name = #name)]
             #item
+
+            #inner_binding
         }
     }
 }
@@ -72,4 +103,66 @@ mod tests {
         );
         assert_eq!(expected.to_string(), expanded.to_string());
     }
+
+    #[test]
+    fn test_map_with_inner() {
+        let map = Map::parse(
+            parse_quote!(inner = "INNER_TEMPLATE"),
+            parse_quote!(
+                static OUTER: Array<u32> = Array::new();
+            ),
+        )
+        .unwrap();
+        let expanded = map.expand();
+        let binding_bytes: &[u8] = b"OUTER\0INNER_TEMPLATE\0";
+        let expected = quote!(
+            #[unsafe(link_section = "maps")]
+            #[unsafe(export_name = "OUTER")]
+            static OUTER: Array<u32> = Array::new();
+
+            #[unsafe(link_section = ".maps.inner")]
+            #[used]
+            #[allow(non_upper_case_globals)]
+            static __inner_map_binding_OUTER: [u8; 21usize] = [#(#binding_bytes),*];
+        );
+        assert_eq!(expected.to_string(), expanded.to_string());
+    }
+
+    #[test]
+    fn test_map_with_name_and_inner() {
+        let map = Map::parse(
+            parse_quote!(name = "my_map", inner = "my_template"),
+            parse_quote!(
+                static OUTER: Array<u32> = Array::new();
+            ),
+        )
+        .unwrap();
+        let expanded = map.expand();
+        let binding_bytes: &[u8] = b"my_map\0my_template\0";
+        let expected = quote!(
+            #[unsafe(link_section = "maps")]
+            #[unsafe(export_name = "my_map")]
+            static OUTER: Array<u32> = Array::new();
+
+            #[unsafe(link_section = ".maps.inner")]
+            #[used]
+            #[allow(non_upper_case_globals)]
+            static __inner_map_binding_my_map: [u8; 19usize] = [#(#binding_bytes),*];
+        );
+        assert_eq!(expected.to_string(), expanded.to_string());
+    }
+
+    #[test]
+    fn test_map_unknown_arg() {
+        let result = Map::parse(
+            parse_quote!(unknown = "foo"),
+            parse_quote!(
+                static BAR: HashMap<&'static str, u32> = HashMap::new();
+            ),
+        );
+        let Err(err) = result else {
+            panic!("expected parse error for unknown argument")
+        };
+        assert_eq!(err.to_string(), "invalid argument");
+    }
 }
diff --git a/aya-obj/src/btf/btf.rs b/aya-obj/src/btf/btf.rs
index e08de4e9e..713f5f854 100644
--- a/aya-obj/src/btf/btf.rs
+++ b/aya-obj/src/btf/btf.rs
@@ -160,6 +160,27 @@ pub enum BtfError {
     /// unable to get symbol name
     #[error("Unable to get symbol name")]
     InvalidSymbolName,
+
+    /// Inner map definition cannot be pinned.
+    #[error("BTF map `{name}`: inner map definition cannot be pinned")]
+    InnerMapCannotBePinned {
+        /// The name of the map with the invalid definition.
+        name: String,
+    },
+
+    /// Multi-level map-in-map is not supported.
+    #[error("BTF map `{name}`: multi-level map-in-map is not supported")]
+    MultiLevelMapInMapNotSupported {
+        /// The name of the map with the invalid definition.
+        name: String,
+    },
+
+    /// The `values` spec must be a zero-sized array.
+    #[error("BTF map `{name}`: `values` spec is not a zero-sized array")]
+    InvalidValuesSpec {
+        /// The name of the map with the invalid definition.
+        name: String,
+    },
 }
 
 /// Available BTF features
diff --git a/aya-obj/src/maps.rs b/aya-obj/src/maps.rs
index e9dbc4561..85c6eaab0 100644
--- a/aya-obj/src/maps.rs
+++ b/aya-obj/src/maps.rs
@@ -251,6 +251,63 @@ impl Map {
             Self::Btf(m) => Some(m.symbol_index),
         }
     }
+
+    /// Returns the inner map definition, in case of a map of maps.
+    pub fn inner(&self) -> Option<Self> {
+        match self {
+            Self::Legacy(m) => m.inner_def.as_ref().map(|inner_def| {
+                Self::Legacy(LegacyMap {
+                    def: *inner_def,
+                    inner_def: None,
+                    // The inner map is a synthetic object with no ELF presence
+                    // of its own, so use neutral metadata values.
+                    section_index: 0,
+                    section_kind: EbpfSectionKind::Undefined,
+                    symbol_index: None,
+                    data: Vec::new(),
+                })
+            }),
+            Self::Btf(m) => m.inner_def.as_ref().map(|inner_def| {
+                Self::Btf(BtfMap {
+                    def: *inner_def,
+                    inner_def: None,
+                    // The inner map is a synthetic object with no ELF presence
+                    // of its own, so use neutral metadata values.
+                    section_index: 0,
+                    symbol_index: 0,
+                    data: Vec::new(),
+                })
+            }),
+        }
+    }
+
+    /// Creates a new legacy map definition programmatically.
+    ///
+    /// This is useful for creating inner maps dynamically for map-of-maps types.
+    pub const fn new_legacy(
+        map_type: u32,
+        key_size: u32,
+        value_size: u32,
+        max_entries: u32,
+        flags: u32,
+    ) -> Self {
+        Self::Legacy(LegacyMap {
+            def: bpf_map_def {
+                map_type,
+                key_size,
+                value_size,
+                max_entries,
+                map_flags: flags,
+                id: 0,
+                pinning: PinningType::None,
+            },
+            inner_def: None,
+            section_index: 0,
+            section_kind: EbpfSectionKind::Undefined,
+            symbol_index: None,
+            data: Vec::new(),
+        })
+    }
 }
 
 /// A map declared with legacy BPF map declaration style, most likely from a `maps` section.
@@ -261,6 +318,8 @@ impl Map {
 pub struct LegacyMap {
     /// The definition of the map
     pub def: bpf_map_def,
+    /// The definition of the inner map, in case of a map of maps.
+    pub inner_def: Option<bpf_map_def>,
     /// The section index
     pub section_index: usize,
     /// The section kind
@@ -280,6 +339,8 @@ pub struct LegacyMap {
 pub struct BtfMap {
     /// The definition of the map
     pub def: BtfMapDef,
+    /// The definition of the inner map, in case of a map of maps.
+    pub(crate) inner_def: Option<BtfMapDef>,
     pub(crate) section_index: usize,
     pub(crate) symbol_index: usize,
     pub(crate) data: Vec<u8>,
diff --git a/aya-obj/src/obj.rs b/aya-obj/src/obj.rs
index ccb37527e..a7856b642 100644
--- a/aya-obj/src/obj.rs
+++ b/aya-obj/src/obj.rs
@@ -25,6 +25,7 @@ use object::{
 use crate::{
     btf::{
         Array, Btf, BtfError, BtfExt, BtfFeatures, BtfType, DataSecEntry, FuncSecInfo, LineSecInfo,
+        Struct,
     },
     generated::{
         BPF_CALL, BPF_F_RDONLY_PROG, BPF_JMP, BPF_K, bpf_func_id, bpf_insn, bpf_map_info,
@@ -146,6 +147,8 @@ pub struct Object {
     pub programs: HashMap<String, Program>,
     /// Functions
     pub functions: BTreeMap<(usize, u64), Function>,
+    /// Inner map bindings: maps outer map name to inner (template) map name.
+    pub(crate) inner_map_bindings: HashMap<String, String>,
     pub(crate) relocations: HashMap<SectionIndex, HashMap<u64, Relocation>>,
     pub(crate) symbol_table: HashMap<usize, Symbol>,
     pub(crate) symbols_by_section: HashMap<SectionIndex, Vec<usize>>,
@@ -530,6 +533,7 @@ impl Object {
             maps: HashMap::new(),
             programs: HashMap::new(),
             functions: BTreeMap::new(),
+            inner_map_bindings: HashMap::new(),
             relocations: HashMap::new(),
             symbol_table: HashMap::new(),
             symbols_by_section: HashMap::new(),
@@ -770,7 +774,7 @@ impl Object {
                 if type_name == section.name {
                     // each btf_var_secinfo contains a map
                     for info in &datasec.entries {
-                        let (map_name, def) = parse_btf_map_def(btf, info)?;
+                        let (map_name, def, inner_def) = parse_btf_map_def(btf, info)?;
                         let symbol_index =
                             maps.get(&map_name)
                                 .ok_or_else(|| ParseError::SymbolNotFound {
@@ -780,6 +784,7 @@ impl Object {
                             map_name,
                             Map::Btf(BtfMap {
                                 def,
+                                inner_def,
                                 section_index: section.index.0,
                                 symbol_index: *symbol_index,
                                 data: Vec::new(),
@@ -825,6 +830,7 @@ impl Object {
                     section_kind: section.kind,
                     symbol_index: Some(sym.index),
                     def,
+                    inner_def: None,
                     data: Vec::new(),
                 }),
             );
@@ -886,12 +892,86 @@ impl Object {
                     );
                 }
             }
+            EbpfSectionKind::MapsInner => self.parse_maps_inner(&section)?,
             EbpfSectionKind::Undefined | EbpfSectionKind::License | EbpfSectionKind::Version => {}
         }
 
         Ok(())
     }
 
+    /// Parses the `.maps.inner` section which contains outer->inner map bindings.
+    ///
+    /// This is an aya-specific mechanism for declaring inner map bindings at compile time,
+    /// used by the legacy `#[map(inner = "...")]` macro. This mechanism is NOT compatible
+    /// with libbpf loaders.
+    ///
+    /// Unlike libbpf which uses BTF relocations within the `.maps` section
+    /// (see <https://patchwork.ozlabs.org/comment/2418417/>), this legacy system uses a
+    /// separate section containing null-terminated string pairs.
+    ///
+    /// For libbpf compatibility, use `#[btf_map]` with `aya_ebpf::btf_maps::{ArrayOfMaps, HashOfMaps}`
+    /// which use BTF relocations that both aya and libbpf can process.
+    ///
+    /// Format: `"outer_name\0inner_name\0"` pairs, emitted by the `#[map(inner = "...")]` macro.
+    fn parse_maps_inner(&mut self, section: &Section<'_>) -> Result<(), ParseError> {
+        let data = section.data;
+        let mut offset = 0;
+
+        while offset < data.len() {
+            // Read outer map name (null-terminated).
+            let Some(outer_len) = data[offset..].iter().position(|&b| b == 0) else {
+                return Err(ParseError::InvalidMapsInnerSection {
+                    offset,
+                    msg: "unterminated outer map name",
+                });
+            };
+
+            let outer_name =
+                core::str::from_utf8(&data[offset..offset + outer_len]).map_err(|_utf8_err| {
+                    ParseError::InvalidMapsInnerSection {
+                        offset,
+                        msg: "invalid UTF-8 in outer map name",
+                    }
+                })?;
+            offset += outer_len + 1; // skip null terminator
+
+            // Read inner map name (null-terminated).
+            let Some(inner_len) = data[offset..].iter().position(|&b| b == 0) else {
+                return Err(ParseError::InvalidMapsInnerSection {
+                    offset,
+                    msg: "unterminated inner map name",
+                });
+            };
+
+            let inner_name =
+                core::str::from_utf8(&data[offset..offset + inner_len]).map_err(|_utf8_err| {
+                    ParseError::InvalidMapsInnerSection {
+                        offset,
+                        msg: "invalid UTF-8 in inner map name",
+                    }
+                })?;
+            offset += inner_len + 1; // skip null terminator
+
+            if outer_name.is_empty() || inner_name.is_empty() {
+                return Err(ParseError::InvalidMapsInnerSection {
+                    offset,
+                    msg: "empty outer or inner map name",
+                });
+            }
+
+            self.inner_map_bindings
+                .insert(outer_name.to_owned(), inner_name.to_owned());
+        }
+
+        Ok(())
+    }
+
+    /// Returns the inner (template) map name bound to the given outer map, if
+    /// any.  These bindings are parsed from the `.maps.inner` ELF section.
+    pub fn inner_map_binding(&self, outer: &str) -> Option<&str> {
+        self.inner_map_bindings.get(outer).map(String::as_str)
+    }
+
     /// Sanitize BPF functions.
     pub fn sanitize_functions(&mut self, features: &Features) {
         for function in self.functions.values_mut() {
@@ -1009,6 +1089,15 @@ pub enum ParseError {
     /// No BTF parsed for object
     #[error("no BTF parsed for object")]
     NoBTF,
+
+    /// Invalid `.maps.inner` section data.
+    #[error("invalid `.maps.inner` section at offset {offset}: {msg}")]
+    InvalidMapsInnerSection {
+        /// Byte offset within the section where the error occurred.
+        offset: usize,
+        /// Description of the error.
+        msg: &'static str,
+    },
 }
 
 /// Invalid bindings to the bpf type from the parsed/received value.
@@ -1026,6 +1115,8 @@ pub enum EbpfSectionKind {
     Maps,
     /// `.maps`
     BtfMaps,
+    /// `.maps.inner`
+    MapsInner,
     /// A program section
     Program,
     /// `.data`
@@ -1054,6 +1145,10 @@ impl EbpfSectionKind {
             Self::Version
         } else if name.starts_with("maps") {
             Self::Maps
+        // NB: `.maps.inner` must be matched before `.maps` to avoid being
+        // swallowed by the `.starts_with(".maps")` arm below.
+        } else if name == ".maps.inner" {
+            Self::MapsInner
         } else if name.starts_with(".maps") {
             Self::BtfMaps
         } else if name.starts_with(".text") {
@@ -1240,6 +1335,7 @@ fn parse_data_map_section(section: &Section<'_>) -> Map {
         // Data maps don't require symbols to be relocated
         symbol_index: None,
         def,
+        inner_def: None,
         data,
     })
 }
@@ -1263,7 +1359,10 @@ fn parse_map_def(name: &str, data: &[u8]) -> Result<bpf_map_def, ParseError> {
     }
 }
 
-fn parse_btf_map_def(btf: &Btf, info: &DataSecEntry) -> Result<(String, BtfMapDef), BtfError> {
+fn parse_btf_map_def(
+    btf: &Btf,
+    info: &DataSecEntry,
+) -> Result<(String, BtfMapDef, Option<BtfMapDef>), BtfError> {
     let ty = match btf.type_by_id(info.btf_type)? {
         BtfType::Var(var) => var,
         other => {
@@ -1273,7 +1372,6 @@ fn parse_btf_map_def(btf: &Btf, info: &DataSecEntry) -> Result<(String, BtfMapDe
         }
     };
     let map_name = btf.string_at(ty.name_offset)?;
-    let mut map_def = BtfMapDef::default();
 
     let root_type = btf.resolve_type(ty.btf_type)?;
     let s = match btf.type_by_id(root_type)? {
@@ -1285,6 +1383,23 @@ fn parse_btf_map_def(btf: &Btf, info: &DataSecEntry) -> Result<(String, BtfMapDe
         }
     };
 
+    let (map_def, inner_def) = parse_btf_map_struct(btf, s, &map_name, false)?;
+    Ok((map_name.to_string(), map_def, inner_def))
+}
+
+/// Parses BTF struct members into a map definition.
+///
+/// When `is_inner` is true, rejects `values` and `pinning` fields, matching
+/// libbpf behavior for inner map definitions.
+fn parse_btf_map_struct(
+    btf: &Btf,
+    s: &Struct,
+    map_name: &str,
+    is_inner: bool,
+) -> Result<(BtfMapDef, Option<BtfMapDef>), BtfError> {
+    let mut map_def = BtfMapDef::default();
+    let mut inner_map_def = None;
+
     for m in &s.members {
         match btf.string_at(m.name_offset)?.as_ref() {
             "type" => {
@@ -1325,18 +1440,67 @@ fn parse_btf_map_def(btf: &Btf, info: &DataSecEntry) -> Result<(String, BtfMapDe
                 map_def.map_flags = get_map_field(btf, m.btf_type)?;
             }
             "pinning" => {
+                if is_inner {
+                    return Err(BtfError::InnerMapCannotBePinned {
+                        name: map_name.to_owned(),
+                    });
+                }
                 let pinning = get_map_field(btf, m.btf_type)?;
                 map_def.pinning = PinningType::try_from(pinning).unwrap_or_else(|_| {
                     debug!("{pinning} is not a valid pin type. using PIN_NONE");
                     PinningType::None
                 });
             }
+            "values" => {
+                if is_inner {
+                    return Err(BtfError::MultiLevelMapInMapNotSupported {
+                        name: map_name.to_owned(),
+                    });
+                }
+                // The inner map type is encoded as a zero-length array of pointers
+                // to the inner struct, matching libbpf's parse_btf_map_def().
+                let arr = match btf.type_by_id(m.btf_type)? {
+                    BtfType::Array(Array { array, .. }) => array,
+                    other => {
+                        return Err(BtfError::UnexpectedBtfType {
+                            type_id: other.btf_type().unwrap_or(0),
+                        });
+                    }
+                };
+                if arr.len != 0 {
+                    return Err(BtfError::InvalidValuesSpec {
+                        name: map_name.to_owned(),
+                    });
+                }
+                let elem_type_id = btf.resolve_type(arr.element_type)?;
+                let ptr = match btf.type_by_id(elem_type_id)? {
+                    BtfType::Ptr(ptr) => ptr,
+                    other => {
+                        return Err(BtfError::UnexpectedBtfType {
+                            type_id: other.btf_type().unwrap_or(0),
+                        });
+                    }
+                };
+                let inner_struct_id = btf.resolve_type(ptr.btf_type)?;
+                let inner_s = match btf.type_by_id(inner_struct_id)? {
+                    BtfType::Struct(s) => s,
+                    other => {
+                        return Err(BtfError::UnexpectedBtfType {
+                            type_id: other.btf_type().unwrap_or(0),
+                        });
+                    }
+                };
+                let (inner_def, _) = parse_btf_map_struct(btf, inner_s, map_name, true)?;
+                inner_map_def = Some(inner_def);
+                // Map-of-maps value is always an fd (u32).
+                map_def.value_size = size_of::<u32>() as u32;
+            }
             other => {
                 debug!("skipping unknown map section: {other}");
             }
         }
     }
-    Ok((map_name.to_string(), map_def))
+    Ok((map_def, inner_map_def))
 }
 
 /// Parses a [`bpf_map_info`] into a [`Map`].
@@ -1353,6 +1517,7 @@ pub const fn parse_map_info(info: bpf_map_info, pinned: PinningType) -> Map {
                 btf_key_type_id: info.btf_key_type_id,
                 btf_value_type_id: info.btf_value_type_id,
             },
+            inner_def: None,
             section_index: 0,
             symbol_index: 0,
             data: Vec::new(),
@@ -1368,6 +1533,7 @@ pub const fn parse_map_info(info: bpf_map_info, pinned: PinningType) -> Map {
                 pinning: pinned,
                 id: info.id,
             },
+            inner_def: None,
             section_index: 0,
             symbol_index: None,
             section_kind: EbpfSectionKind::Undefined,
@@ -1632,6 +1798,7 @@ mod tests {
                     pinning: PinningType::None,
                 },
                 data,
+                ..
             }) if data == map_data && value_size == map_data.len() as u32
         )
     }
@@ -2629,6 +2796,7 @@ mod tests {
                     id: 1,
                     pinning: PinningType::None,
                 },
+                inner_def: None,
                 section_index: 1,
                 section_kind: EbpfSectionKind::Rodata,
                 symbol_index: Some(1),
diff --git a/aya-obj/src/relocation.rs b/aya-obj/src/relocation.rs
index 67a5d8307..f86d69d67 100644
--- a/aya-obj/src/relocation.rs
+++ b/aya-obj/src/relocation.rs
@@ -519,6 +519,7 @@ mod test {
     fn fake_legacy_map(symbol_index: usize) -> Map {
         Map::Legacy(LegacyMap {
             def: Default::default(),
+            inner_def: None,
             section_index: 0,
             section_kind: EbpfSectionKind::Undefined,
             symbol_index: Some(symbol_index),
@@ -529,6 +530,7 @@ mod test {
     fn fake_btf_map(symbol_index: usize) -> Map {
         Map::Btf(BtfMap {
             def: Default::default(),
+            inner_def: None,
             section_index: 0,
             symbol_index,
             data: Vec::new(),
diff --git a/aya/src/bpf.rs b/aya/src/bpf.rs
index 1777399cc..1a410b0d6 100644
--- a/aya/src/bpf.rs
+++ b/aya/src/bpf.rs
@@ -1,7 +1,7 @@
 use std::{
     borrow::Cow,
     collections::{HashMap, HashSet},
-    fs, io,
+    fs, io, iter,
     os::fd::{AsFd as _, AsRawFd as _},
     path::{Path, PathBuf},
     sync::{Arc, LazyLock},
@@ -497,38 +497,93 @@ impl<'a> EbpfLoader<'a> {
         if let Some(btf) = &btf {
             obj.relocate_btf(btf)?;
         }
-        let mut maps = HashMap::new();
-        for (name, mut obj) in obj.maps.drain() {
+
+        const fn is_map_of_maps(map_type: bpf_map_type) -> bool {
+            matches!(
+                map_type,
+                bpf_map_type::BPF_MAP_TYPE_ARRAY_OF_MAPS | bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS
+            )
+        }
+
+        // The kernel requires inner_map_fd when creating map-of-maps, so inner
+        // maps must be created first. Partition into regular maps and map-of-maps.
+        let mut regular_maps: Vec<(String, aya_obj::Map)> = Vec::new();
+        let mut maps_of_maps: Vec<(String, aya_obj::Map)> = Vec::new();
+
+        for (name, map_obj) in obj.maps.drain() {
             if let (false, EbpfSectionKind::Bss | EbpfSectionKind::Data | EbpfSectionKind::Rodata) =
-                (FEATURES.bpf_global_data(), obj.section_kind())
+                (FEATURES.bpf_global_data(), map_obj.section_kind())
             {
                 continue;
             }
+            let map_type: bpf_map_type = map_obj.map_type().try_into().map_err(MapError::from)?;
+            if is_map_of_maps(map_type) {
+                maps_of_maps.push((name, map_obj));
+            } else {
+                regular_maps.push((name, map_obj));
+            }
+        }
+
+        let mut maps: HashMap<String, MapData> = HashMap::new();
+
+        // Regular maps first, so they're available as inner maps below.
+        for ((name, mut map_obj), is_map_of_maps) in regular_maps
+            .into_iter()
+            .zip(iter::repeat(false))
+            .chain(maps_of_maps.into_iter().zip(iter::repeat(true)))
+        {
             let num_cpus = || {
                 Ok(nr_cpus().map_err(|(path, error)| EbpfError::FileError {
                     path: PathBuf::from(path),
                     error,
                 })? as u32)
             };
-            let map_type: bpf_map_type = obj.map_type().try_into().map_err(MapError::from)?;
-            if let Some(max_entries) = max_entries_override(
+            let map_type: bpf_map_type = map_obj.map_type().try_into().map_err(MapError::from)?;
+            if let Some(max_entries_val) = max_entries_override(
                 map_type,
                 max_entries.get(name.as_str()).copied(),
-                || obj.max_entries(),
+                || map_obj.max_entries(),
                 num_cpus,
                 || page_size() as u32,
             )? {
-                obj.set_max_entries(max_entries)
+                map_obj.set_max_entries(max_entries_val)
             }
             if let Some(value_size) = value_size_override(map_type) {
-                obj.set_value_size(value_size)
+                map_obj.set_value_size(value_size)
             }
+
             let btf_fd = btf_fd.as_deref().map(|fd| fd.as_fd());
+
+            // The kernel requires an inner map fd when creating a map-of-maps.
+            let btf_inner_map;
+            let inner_map_fd = if is_map_of_maps {
+                if let Some(inner) = map_obj.inner() {
+                    // Try using a BTF definition of the inner map.
+                    btf_inner_map = MapData::create(inner, &format!("{name}.inner"), btf_fd)?;
+                    Some(btf_inner_map.fd().as_fd())
+                } else {
+                    // No BTF inner definition; fall back to the `.maps.inner` binding.
+                    let inner_name = obj.inner_map_binding(&name).ok_or_else(|| {
+                        EbpfError::MapError(MapError::MissingInnerMapBinding { name: name.clone() })
+                    })?;
+                    let inner_map = maps.get(inner_name).ok_or_else(|| {
+                        EbpfError::MapError(MapError::InnerMapNotFound {
+                            name: name.clone(),
+                            inner_name: inner_name.to_owned(),
+                        })
+                    })?;
+                    Some(inner_map.fd().as_fd())
+                }
+            } else {
+                None
+            };
             let mut map = if let Some(pin_path) = map_pin_path_by_name.get(name.as_str()) {
-                MapData::create_pinned_by_name(pin_path, obj, &name, btf_fd)?
+                MapData::create_pinned_by_name(pin_path, map_obj, &name, btf_fd, inner_map_fd)?
             } else {
-                match obj.pinning() {
-                    PinningType::None => MapData::create(obj, &name, btf_fd)?,
+                match map_obj.pinning() {
+                    PinningType::None => {
+                        MapData::create_with_inner_map_fd(map_obj, &name, btf_fd, inner_map_fd)?
+                    }
                     PinningType::ByName => {
                         // pin maps in /sys/fs/bpf by default to align with libbpf
                         // behavior https://github.com/libbpf/libbpf/blob/v1.2.2/src/libbpf.c#L2161.
@@ -537,7 +592,7 @@ impl<'a> EbpfLoader<'a> {
                             .unwrap_or_else(|| Path::new("/sys/fs/bpf"));
                         let path = path.join(&name);
 
-                        MapData::create_pinned_by_name(path, obj, &name, btf_fd)?
+                        MapData::create_pinned_by_name(path, map_obj, &name, btf_fd, inner_map_fd)?
                     }
                 }
             };
@@ -778,6 +833,8 @@ fn parse_map(
         bpf_map_type::BPF_MAP_TYPE_DEVMAP_HASH => Map::DevMapHash(map),
         bpf_map_type::BPF_MAP_TYPE_XSKMAP => Map::XskMap(map),
         bpf_map_type::BPF_MAP_TYPE_SK_STORAGE => Map::SkStorage(map),
+        bpf_map_type::BPF_MAP_TYPE_ARRAY_OF_MAPS => Map::ArrayOfMaps(map),
+        bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS => Map::HashOfMaps(map),
         m_type => {
             if allow_unsupported_maps {
                 Map::Unsupported(map)
diff --git a/aya/src/maps/mod.rs b/aya/src/maps/mod.rs
index 3ded408cd..175937349 100644
--- a/aya/src/maps/mod.rs
+++ b/aya/src/maps/mod.rs
@@ -76,6 +76,7 @@ pub mod bloom_filter;
 pub mod hash_map;
 mod info;
 pub mod lpm_trie;
+pub mod of_maps;
 pub mod perf;
 pub mod queue;
 pub mod ring_buf;
@@ -90,6 +91,7 @@ pub use bloom_filter::BloomFilter;
 pub use hash_map::{HashMap, PerCpuHashMap};
 pub use info::{MapInfo, MapType, loaded_maps};
 pub use lpm_trie::LpmTrie;
+pub use of_maps::{ArrayOfMaps, HashOfMaps};
 pub use perf::PerfEventArray;
 pub use queue::Queue;
 pub use ring_buf::RingBuf;
@@ -99,9 +101,78 @@ pub use stack::Stack;
 pub use stack_trace::StackTraceMap;
 pub use xdp::{CpuMap, DevMap, DevMapHash, XskMap};
 
+/// Trait for constructing a typed map from [`MapData`].
+///
+/// This is used by map-of-maps types ([`ArrayOfMaps`], [`HashOfMaps`]) to
+/// let callers specify the expected inner map type when retrieving entries.
+///
+/// This trait is sealed and cannot be implemented outside of this crate.
+pub trait FromMapData: Sized + sealed::FromMapData {
+    /// Constructs a typed map from raw [`MapData`].
+    fn from_map_data(map_data: MapData) -> Result<Self, MapError>;
+}
+
+impl<T: sealed::FromMapData> FromMapData for T {
+    fn from_map_data(map_data: MapData) -> Result<Self, MapError> {
+        <Self as sealed::FromMapData>::from_map_data(map_data)
+    }
+}
+
+/// Marker for map types that the kernel supports as inner maps.
+///
+/// Types implementing this trait can be passed to
+/// [`ArrayOfMaps::set`] and [`HashOfMaps::insert`].
+///
+/// This trait is sealed and cannot be implemented outside of this crate.
+pub trait InnerMap: sealed::InnerMap {
+    /// Returns the map file descriptor.
+    fn fd(&self) -> &MapFd;
+}
+
+impl<T: sealed::InnerMap> InnerMap for T {
+    fn fd(&self) -> &MapFd {
+        sealed::InnerMap::inner_map_fd(self)
+    }
+}
+
+mod sealed {
+    use super::{MapData, MapError, MapFd};
+
+    #[expect(unnameable_types, reason = "intentionally unnameable sealed trait")]
+    pub trait FromMapData: Sized {
+        /// Constructs a typed map from raw [`MapData`].
+        fn from_map_data(map_data: MapData) -> Result<Self, MapError>;
+    }
+
+    #[expect(unnameable_types, reason = "intentionally unnameable sealed trait")]
+    pub trait InnerMap {
+        /// Returns the map file descriptor.
+        fn inner_map_fd(&self) -> &MapFd;
+    }
+}
+
 #[derive(Error, Debug)]
 /// Errors occuring from working with Maps
 pub enum MapError {
+    /// Missing inner map binding for a map-of-maps.
+    #[error(
+        "map `{name}` is a map-of-maps but has no inner map binding; \
+             use #[map(inner = \"<template>\")] or ensure the BTF definition includes a `values` field"
+    )]
+    MissingInnerMapBinding {
+        /// The map name.
+        name: String,
+    },
+
+    /// Inner map not found for a map-of-maps.
+    #[error("inner map `{inner_name}` not found for map-of-maps `{name}`")]
+    InnerMapNotFound {
+        /// The outer map name.
+        name: String,
+        /// The inner map name.
+        inner_name: String,
+    },
+
     /// Invalid map type encontered
     #[error("invalid map type {map_type}")]
     InvalidMapType {
@@ -217,7 +288,8 @@ impl MapFd {
         Self { fd }
     }
 
-    fn try_clone(&self) -> io::Result<Self> {
+    /// Creates a new instance that shares the same underlying file description as `self`.
+    pub fn try_clone(&self) -> io::Result<Self> {
         let Self { fd } = self;
         let fd = fd.try_clone()?;
         Ok(Self { fd })
@@ -236,6 +308,8 @@ impl AsFd for MapFd {
 pub enum Map {
     /// An [`Array`] map.
     Array(MapData),
+    /// An [`ArrayOfMaps`] map.
+    ArrayOfMaps(MapData),
     /// A [`BloomFilter`] map.
     BloomFilter(MapData),
     /// A [`CpuMap`] map.
@@ -246,6 +320,8 @@ pub enum Map {
     DevMapHash(MapData),
     /// A [`HashMap`] map.
     HashMap(MapData),
+    /// A [`HashOfMaps`] map.
+    HashOfMaps(MapData),
     /// A [`LpmTrie`] map.
     LpmTrie(MapData),
     /// A [`HashMap`] map that uses a LRU eviction policy.
@@ -285,11 +361,13 @@ impl Map {
     const fn map_type(&self) -> u32 {
         match self {
             Self::Array(map) => map.obj.map_type(),
+            Self::ArrayOfMaps(map) => map.obj.map_type(),
             Self::BloomFilter(map) => map.obj.map_type(),
             Self::CpuMap(map) => map.obj.map_type(),
             Self::DevMap(map) => map.obj.map_type(),
             Self::DevMapHash(map) => map.obj.map_type(),
             Self::HashMap(map) => map.obj.map_type(),
+            Self::HashOfMaps(map) => map.obj.map_type(),
             Self::LpmTrie(map) => map.obj.map_type(),
             Self::LruHashMap(map) => map.obj.map_type(),
             Self::PerCpuArray(map) => map.obj.map_type(),
@@ -316,11 +394,13 @@ impl Map {
     pub fn pin<P: AsRef<Path>>(&self, path: P) -> Result<(), PinError> {
         match self {
             Self::Array(map) => map.pin(path),
+            Self::ArrayOfMaps(map) => map.pin(path),
             Self::BloomFilter(map) => map.pin(path),
             Self::CpuMap(map) => map.pin(path),
             Self::DevMap(map) => map.pin(path),
             Self::DevMapHash(map) => map.pin(path),
             Self::HashMap(map) => map.pin(path),
+            Self::HashOfMaps(map) => map.pin(path),
             Self::LpmTrie(map) => map.pin(path),
             Self::LruHashMap(map) => map.pin(path),
             Self::PerCpuArray(map) => map.pin(path),
@@ -374,8 +454,8 @@ impl Map {
             bpf_map_type::BPF_MAP_TYPE_RINGBUF => Self::RingBuf(map_data),
             bpf_map_type::BPF_MAP_TYPE_BLOOM_FILTER => Self::BloomFilter(map_data),
             bpf_map_type::BPF_MAP_TYPE_CGROUP_ARRAY => Self::Unsupported(map_data),
-            bpf_map_type::BPF_MAP_TYPE_ARRAY_OF_MAPS => Self::Unsupported(map_data),
-            bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS => Self::Unsupported(map_data),
+            bpf_map_type::BPF_MAP_TYPE_ARRAY_OF_MAPS => Self::ArrayOfMaps(map_data),
+            bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS => Self::HashOfMaps(map_data),
             bpf_map_type::BPF_MAP_TYPE_CGROUP_STORAGE_DEPRECATED => Self::Unsupported(map_data),
             bpf_map_type::BPF_MAP_TYPE_REUSEPORT_SOCKARRAY => Self::Unsupported(map_data),
             bpf_map_type::BPF_MAP_TYPE_SK_STORAGE => Self::SkStorage(map_data),
@@ -393,6 +473,36 @@ impl Map {
         };
         Ok(map)
     }
+
+    /// Returns the file descriptor of the map.
+    pub const fn fd(&self) -> &MapFd {
+        match self {
+            Self::Array(map) => map.fd(),
+            Self::ArrayOfMaps(map) => map.fd(),
+            Self::BloomFilter(map) => map.fd(),
+            Self::CpuMap(map) => map.fd(),
+            Self::DevMap(map) => map.fd(),
+            Self::DevMapHash(map) => map.fd(),
+            Self::HashMap(map) => map.fd(),
+            Self::HashOfMaps(map) => map.fd(),
+            Self::LpmTrie(map) => map.fd(),
+            Self::LruHashMap(map) => map.fd(),
+            Self::PerCpuArray(map) => map.fd(),
+            Self::PerCpuHashMap(map) => map.fd(),
+            Self::PerCpuLruHashMap(map) => map.fd(),
+            Self::PerfEventArray(map) => map.fd(),
+            Self::ProgramArray(map) => map.fd(),
+            Self::Queue(map) => map.fd(),
+            Self::RingBuf(map) => map.fd(),
+            Self::SockHash(map) => map.fd(),
+            Self::SockMap(map) => map.fd(),
+            Self::SkStorage(map) => map.fd(),
+            Self::Stack(map) => map.fd(),
+            Self::StackTraceMap(map) => map.fd(),
+            Self::Unsupported(map) => map.fd(),
+            Self::XskMap(map) => map.fd(),
+        }
+    }
 }
 
 // Implements map pinning for different map implementations
@@ -449,7 +559,8 @@ impl_map_pin!((K, V) {
 
 // Implements TryFrom<Map> for different map implementations. Different map implementations can be
 // constructed from different variants of the map enum. Also, the implementation may have type
-// parameters (which we assume all have the bound `Pod` and nothing else).
+// parameters. The dispatch arm adds `Pod` bounds explicitly before forwarding to the @impl arm,
+// which accepts arbitrary bounds and is also used by impl_try_from_map_of_maps.
 macro_rules! impl_try_from_map {
     // At the root the type parameters are marked as a single token tree which will be pasted into
     // the invocation for each type. Note that the later patterns require that the token tree be
@@ -465,23 +576,24 @@ macro_rules! impl_try_from_map {
     ($(#[$meta:meta])* <$ty_param:tt> $ty:ident) => {
         impl_try_from_map!($(#[$meta])* <$ty_param> $ty from $ty);
     };
-    // Dispatch for each of the lifetimes.
+    // Dispatch for each of the lifetimes, adding Pod bounds explicitly.
     (
         $(#[$meta:meta])* <($($ty_param:ident),*)> $ty:ident from $($variant:ident)|+
     ) => {
-        impl_try_from_map!($(#[$meta])* <'a> ($($ty_param),*) $ty from $($variant)|+);
-        impl_try_from_map!($(#[$meta])* <'a mut> ($($ty_param),*) $ty from $($variant)|+);
-        impl_try_from_map!($(#[$meta])* <> ($($ty_param),*) $ty from $($variant)|+);
+        impl_try_from_map!(@impl $(#[$meta])* <'a> ($($ty_param: Pod),*) $ty from $($variant)|+);
+        impl_try_from_map!(@impl $(#[$meta])* <'a mut> ($($ty_param: Pod),*) $ty from $($variant)|+);
+        impl_try_from_map!(@impl $(#[$meta])* <> ($($ty_param: Pod),*) $ty from $($variant)|+);
     };
-    // An individual impl.
-    (
+    // An individual impl with explicit bounds. Used by both impl_try_from_map
+    // and impl_try_from_map_of_maps via the @impl internal rule.
+    (@impl
         $(#[$meta:meta])*
         <$($l:lifetime $($m:ident)?)?>
-        ($($ty_param:ident),*)
+        ($($ty_param:ident $(: $bound:path)?),*)
         $ty:ident from $($variant:ident)|+
     ) => {
         $(#[$meta])*
-        impl<$($l,)? $($ty_param: Pod),*> TryFrom<$(&$l $($m)?)? Map>
+        impl<$($l,)? $($ty_param $(: $bound)?),*> TryFrom<$(&$l $($m)?)? Map>
             for $ty<$(&$l $($m)?)? MapData, $($ty_param),*>
         {
             type Error = MapError;
@@ -526,6 +638,144 @@ impl_try_from_map!((K, V) {
     PerCpuHashMap from PerCpuHashMap|PerCpuLruHashMap,
 });
 
+// ArrayOfMaps and HashOfMaps need an unconstrained V in TryFrom conversions.
+// Delegates to the @impl arm of impl_try_from_map to avoid duplicating the
+// match body.
+macro_rules! impl_try_from_map_of_maps {
+    ($ty:ident) => {
+        impl_try_from_map_of_maps!($ty <>);
+    };
+    ($ty:ident <$($pre:ident : $pre_bound:path),*>) => {
+        impl_try_from_map!(@impl <'a> ($($pre: $pre_bound,)* V) $ty from $ty);
+        impl_try_from_map!(@impl <'a mut> ($($pre: $pre_bound,)* V) $ty from $ty);
+        impl_try_from_map!(@impl <> ($($pre: $pre_bound,)* V) $ty from $ty);
+    };
+}
+
+impl_try_from_map_of_maps!(ArrayOfMaps);
+impl_try_from_map_of_maps!(HashOfMaps<K: Pod>);
+
+// Implements `sealed::FromMapData` for map types that the kernel supports as inner maps.
+// Excluded: ProgramArray (no map_meta_equal), ArrayOfMaps/HashOfMaps (multi-level nesting
+// forbidden).
+macro_rules! impl_from_map_data {
+    ($ty_param:tt { $($ty:ident),+ $(,)? }) => {
+        $(impl_from_map_data!(<$ty_param> $ty);)+
+    };
+    (<($($ty_param:ident),*)> $ty:ident) => {
+        impl<$($ty_param: Pod),*> sealed::FromMapData for $ty<MapData, $($ty_param),*> {
+            fn from_map_data(map_data: MapData) -> Result<Self, MapError> {
+                Self::new(map_data)
+            }
+        }
+        impl<$($ty_param: Pod),*> sealed::InnerMap for $ty<MapData, $($ty_param),*> {
+            fn inner_map_fd(&self) -> &MapFd {
+                self.inner.fd()
+            }
+        }
+    };
+}
+
+impl_from_map_data!(() {
+    CpuMap, DevMap, DevMapHash,
+    SockMap, StackTraceMap, XskMap,
+});
+
+// PerfEventArray and RingBuf use a different field layout, so InnerMap is
+// implemented manually below.
+impl sealed::FromMapData for PerfEventArray<MapData> {
+    fn from_map_data(map_data: MapData) -> Result<Self, MapError> {
+        Self::new(map_data)
+    }
+}
+impl sealed::InnerMap for PerfEventArray<MapData> {
+    fn inner_map_fd(&self) -> &MapFd {
+        self.map_data().fd()
+    }
+}
+
+impl sealed::FromMapData for RingBuf<MapData> {
+    fn from_map_data(map_data: MapData) -> Result<Self, MapError> {
+        Self::new(map_data)
+    }
+}
+impl sealed::InnerMap for RingBuf<MapData> {
+    fn inner_map_fd(&self) -> &MapFd {
+        self.map_data().fd()
+    }
+}
+
+impl_from_map_data!((V) {
+    Array, BloomFilter, PerCpuArray,
+    Queue, SockHash, SkStorage, Stack,
+});
+
+impl_from_map_data!((K, V) {
+    HashMap, LpmTrie, PerCpuHashMap,
+});
+
+impl sealed::FromMapData for MapData {
+    fn from_map_data(map_data: MapData) -> Result<Self, MapError> {
+        Ok(map_data)
+    }
+}
+
+impl sealed::InnerMap for MapData {
+    fn inner_map_fd(&self) -> &MapFd {
+        self.fd()
+    }
+}
+
+impl sealed::InnerMap for MapFd {
+    fn inner_map_fd(&self) -> &MapFd {
+        self
+    }
+}
+
+// Implements `create()` for map types that can be created standalone for use as inner maps in
+// map-of-maps. Each invocation specifies the kernel map type, key size expression, the type
+// parameter used for value size, and a name for the created map.
+macro_rules! impl_create_map {
+    ($ty_param:tt {
+        $($ty:ident($map_type:ident, $key_size:expr, $val:ident, $name:literal)),+ $(,)?
+    }) => {
+        $(impl_create_map!(<$ty_param> $ty($map_type, $key_size, $val, $name));)+
+    };
+    (<($($ty_param:ident),+)> $ty:ident($map_type:ident, $key_size:expr, $val:ident, $name:literal)) => {
+        impl<$($ty_param: Pod),+> $ty<MapData, $($ty_param),+> {
+            /// Creates a standalone map, not loaded from an eBPF object file.
+            ///
+            /// This is useful for creating inner maps to insert into map-of-maps
+            /// types like [`ArrayOfMaps`](crate::maps::ArrayOfMaps) or
+            /// [`HashOfMaps`](crate::maps::HashOfMaps).
+            pub fn create(max_entries: u32, flags: u32) -> Result<Self, MapError> {
+                let obj = aya_obj::Map::new_legacy(
+                    aya_obj::generated::bpf_map_type::$map_type as u32,
+                    $key_size,
+                    size_of::<$val>() as u32,
+                    max_entries,
+                    flags,
+                );
+                Self::new(MapData::create(obj, $name, None)?)
+            }
+        }
+    };
+}
+
+impl_create_map!((V) {
+    Array(BPF_MAP_TYPE_ARRAY, size_of::<u32>() as u32, V, "standalone_array"),
+    PerCpuArray(BPF_MAP_TYPE_PERCPU_ARRAY, size_of::<u32>() as u32, V, "standalone_percpu_array"),
+    BloomFilter(BPF_MAP_TYPE_BLOOM_FILTER, 0, V, "standalone_bloom_filter"),
+    Queue(BPF_MAP_TYPE_QUEUE, 0, V, "standalone_queue"),
+    Stack(BPF_MAP_TYPE_STACK, 0, V, "standalone_stack"),
+});
+
+impl_create_map!((K, V) {
+    HashMap(BPF_MAP_TYPE_HASH, size_of::<K>() as u32, V, "standalone_hash"),
+    PerCpuHashMap(BPF_MAP_TYPE_PERCPU_HASH, size_of::<K>() as u32, V, "standalone_percpu_hash"),
+    LpmTrie(BPF_MAP_TYPE_LPM_TRIE, size_of::<lpm_trie::Key<K>>() as u32, V, "standalone_lpm_trie"),
+});
+
 pub(crate) const fn check_bounds(map: &MapData, index: u32) -> Result<(), MapError> {
     let max_entries = map.obj.max_entries();
     if index >= max_entries {
@@ -570,9 +820,19 @@ pub struct MapData {
 impl MapData {
     /// Creates a new map with the provided `name`
     pub fn create(
+        obj: aya_obj::Map,
+        name: &str,
+        btf_fd: Option<BorrowedFd<'_>>,
+    ) -> Result<Self, MapError> {
+        Self::create_with_inner_map_fd(obj, name, btf_fd, None)
+    }
+
+    /// Creates a new map with the provided `name` and optional `inner_map_fd` for map-of-maps types.
+    pub(crate) fn create_with_inner_map_fd(
         mut obj: aya_obj::Map,
         name: &str,
         btf_fd: Option<BorrowedFd<'_>>,
+        inner_map_fd: Option<BorrowedFd<'_>>,
     ) -> Result<Self, MapError> {
         let c_name = CString::new(name)
             .map_err(|std::ffi::NulError { .. }| MapError::InvalidName { name: name.into() })?;
@@ -595,11 +855,12 @@ impl MapData {
             }
         }
 
-        let fd =
-            bpf_create_map(&c_name, &obj, btf_fd).map_err(|io_error| MapError::CreateError {
+        let fd = bpf_create_map(&c_name, &obj, btf_fd, inner_map_fd).map_err(|io_error| {
+            MapError::CreateError {
                 name: name.into(),
                 io_error,
-            })?;
+            }
+        })?;
         Ok(Self {
             obj,
             fd: MapFd::from_fd(fd),
@@ -611,6 +872,7 @@ impl MapData {
         obj: aya_obj::Map,
         name: &str,
         btf_fd: Option<BorrowedFd<'_>>,
+        inner_map_fd: Option<BorrowedFd<'_>>,
     ) -> Result<Self, MapError> {
         use std::os::unix::ffi::OsStrExt as _;
 
@@ -634,7 +896,7 @@ impl MapData {
                 fd: MapFd::from_fd(fd),
             })
         } else {
-            let map = Self::create(obj, name, btf_fd)?;
+            let map = Self::create_with_inner_map_fd(obj, name, btf_fd, inner_map_fd)?;
             map.pin(path).map_err(|error| MapError::PinError {
                 name: Some(name.into()),
                 error,
@@ -989,6 +1251,7 @@ mod test_utils {
                 max_entries: 1024,
                 ..Default::default()
             },
+            inner_def: None,
             section_index: 0,
             section_kind: EbpfSectionKind::Maps,
             data: Vec::new(),
@@ -1008,6 +1271,7 @@ mod test_utils {
                 max_entries,
                 ..Default::default()
             },
+            inner_def: None,
             section_index: 0,
             section_kind: EbpfSectionKind::Maps,
             data: Vec::new(),
diff --git a/aya/src/maps/of_maps/array.rs b/aya/src/maps/of_maps/array.rs
new file mode 100644
index 000000000..34bb4ce92
--- /dev/null
+++ b/aya/src/maps/of_maps/array.rs
@@ -0,0 +1,271 @@
+//! An array of eBPF maps.
+
+use std::{
+    borrow::{Borrow, BorrowMut},
+    fmt,
+    marker::PhantomData,
+    os::fd::{AsFd as _, AsRawFd as _},
+    path::Path,
+};
+
+use crate::{
+    maps::{FromMapData, InnerMap, MapData, MapError, PinError, check_bounds, check_kv_size},
+    sys::{SyscallError, bpf_map_lookup_elem, bpf_map_update_elem},
+};
+
+/// An array of eBPF maps.
+///
+/// An `ArrayOfMaps` stores references to other eBPF maps.
+///
+/// # Minimum kernel version
+///
+/// The minimum kernel version required to use this feature is 4.12.
+#[doc(alias = "BPF_MAP_TYPE_ARRAY_OF_MAPS")]
+pub struct ArrayOfMaps<T, V = MapData> {
+    pub(crate) inner: T,
+    _v: PhantomData<V>,
+}
+
+impl<T: fmt::Debug, V> fmt::Debug for ArrayOfMaps<T, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ArrayOfMaps")
+            .field("inner", &self.inner)
+            .finish()
+    }
+}
+
+impl<T: Borrow<MapData>, V> ArrayOfMaps<T, V> {
+    pub(crate) fn new(map: T) -> Result<Self, MapError> {
+        let data = map.borrow();
+        check_kv_size::<u32, u32>(data)?;
+        Ok(Self {
+            inner: map,
+            _v: PhantomData,
+        })
+    }
+
+    /// Returns the number of elements in the array.
+    ///
+    /// This corresponds to the value of `bpf_map_def::max_entries` on the eBPF side.
+    pub fn len(&self) -> u32 {
+        self.inner.borrow().obj.max_entries()
+    }
+
+    /// Returns true if the array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<T: Borrow<MapData>, V: FromMapData> ArrayOfMaps<T, V> {
+    /// Returns the inner map stored at the given index.
+    ///
+    /// The inner map type `V` is determined by the type parameter on the
+    /// `ArrayOfMaps` itself.
+    ///
+    /// # File descriptor cost
+    ///
+    /// Each call opens a **new file descriptor** to the inner map. The caller
+    /// owns the returned map and its FD is closed on drop. Avoid calling this
+    /// in a tight loop without dropping previous results.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`MapError::OutOfBounds`] if `index` is out of bounds, [`MapError::SyscallError`]
+    /// if `bpf_map_lookup_elem` fails.
+    pub fn get(&self, index: &u32, flags: u64) -> Result<V, MapError> {
+        let data = self.inner.borrow();
+        check_bounds(data, *index)?;
+        let fd = data.fd().as_fd();
+
+        let value: Option<u32> =
+            bpf_map_lookup_elem(fd, index, flags).map_err(|io_error| SyscallError {
+                call: "bpf_map_lookup_elem",
+                io_error,
+            })?;
+        match value {
+            Some(id) => super::map_from_id(id),
+            None => Err(MapError::KeyNotFound),
+        }
+    }
+}
+
+impl<T: BorrowMut<MapData>, V: InnerMap> ArrayOfMaps<T, V> {
+    /// Sets the value of the element at the given index.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`MapError::OutOfBounds`] if `index` is out of bounds, [`MapError::SyscallError`]
+    /// if `bpf_map_update_elem` fails.
+    pub fn set(&mut self, index: u32, value: &V, flags: u64) -> Result<(), MapError> {
+        let data = self.inner.borrow_mut();
+        check_bounds(data, index)?;
+        let fd = data.fd().as_fd();
+        bpf_map_update_elem(fd, Some(&index), &value.fd().as_fd().as_raw_fd(), flags).map_err(
+            |io_error| SyscallError {
+                call: "bpf_map_update_elem",
+                io_error,
+            },
+        )?;
+        Ok(())
+    }
+}
+
+impl<V> ArrayOfMaps<MapData, V> {
+    /// Pins the map to a BPF filesystem.
+    ///
+    /// When a map is pinned it will remain loaded until the corresponding file
+    /// is deleted. All parent directories in the given `path` must already exist.
+    pub fn pin<P: AsRef<Path>>(self, path: P) -> Result<(), PinError> {
+        self.inner.pin(path)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io;
+
+    use assert_matches::assert_matches;
+    use aya_obj::generated::{bpf_cmd, bpf_map_type::BPF_MAP_TYPE_ARRAY_OF_MAPS};
+    use libc::{EFAULT, ENOENT};
+
+    use super::*;
+    use crate::{
+        maps::{Map, test_utils},
+        sys::{SysResult, Syscall, override_syscall},
+    };
+
+    fn new_obj_map() -> aya_obj::Map {
+        test_utils::new_obj_map::<u32>(BPF_MAP_TYPE_ARRAY_OF_MAPS)
+    }
+
+    fn new_map(obj: aya_obj::Map) -> MapData {
+        test_utils::new_map(obj)
+    }
+
+    fn sys_error(value: i32) -> SysResult {
+        Err((-1, io::Error::from_raw_os_error(value)))
+    }
+
+    #[test]
+    fn test_wrong_key_size() {
+        let map = new_map(test_utils::new_obj_map::<u8>(BPF_MAP_TYPE_ARRAY_OF_MAPS));
+        assert_matches!(
+            ArrayOfMaps::<_, MapData>::new(&map),
+            Err(MapError::InvalidKeySize {
+                size: 4,
+                expected: 1
+            })
+        );
+    }
+
+    #[test]
+    fn test_try_from_wrong_map() {
+        let map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_HASH,
+        ));
+        let map = Map::HashMap(map);
+        assert_matches!(
+            ArrayOfMaps::<_, MapData>::try_from(&map),
+            Err(MapError::InvalidMapType { .. })
+        );
+    }
+
+    #[test]
+    fn test_new_ok() {
+        let map = new_map(new_obj_map());
+        let _: ArrayOfMaps<_> = ArrayOfMaps::new(&map).unwrap();
+    }
+
+    #[test]
+    fn test_set_syscall_error() {
+        let mut map = new_map(new_obj_map());
+        let inner_map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_ARRAY,
+        ));
+        let mut arr = ArrayOfMaps::new(&mut map).unwrap();
+
+        override_syscall(|_| sys_error(EFAULT));
+
+        assert_matches!(
+            arr.set(0, &inner_map, 0),
+            Err(MapError::SyscallError(SyscallError {
+                call: "bpf_map_update_elem",
+                ..
+            }))
+        );
+    }
+
+    #[test]
+    fn test_set_ok() {
+        let mut map = new_map(new_obj_map());
+        let inner_map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_ARRAY,
+        ));
+        let mut arr = ArrayOfMaps::new(&mut map).unwrap();
+
+        override_syscall(|call| match call {
+            Syscall::Ebpf {
+                cmd: bpf_cmd::BPF_MAP_UPDATE_ELEM,
+                ..
+            } => Ok(0),
+            _ => sys_error(EFAULT),
+        });
+
+        arr.set(0, &inner_map, 0).unwrap();
+    }
+
+    #[test]
+    fn test_set_out_of_bounds() {
+        let mut map = new_map(new_obj_map());
+        let inner_map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_ARRAY,
+        ));
+        let mut arr = ArrayOfMaps::new(&mut map).unwrap();
+
+        assert_matches!(
+            arr.set(1024, &inner_map, 0),
+            Err(MapError::OutOfBounds { .. })
+        );
+    }
+
+    #[test]
+    fn test_get_syscall_error() {
+        let map = new_map(new_obj_map());
+        let arr = ArrayOfMaps::<_, MapData>::new(&map).unwrap();
+
+        override_syscall(|_| sys_error(EFAULT));
+
+        assert_matches!(
+            arr.get(&0, 0),
+            Err(MapError::SyscallError(SyscallError {
+                call: "bpf_map_lookup_elem",
+                ..
+            }))
+        );
+    }
+
+    #[test]
+    fn test_get_not_found() {
+        let map = new_map(new_obj_map());
+        let arr = ArrayOfMaps::<_, MapData>::new(&map).unwrap();
+
+        override_syscall(|call| match call {
+            Syscall::Ebpf {
+                cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM,
+                ..
+            } => sys_error(ENOENT),
+            _ => sys_error(EFAULT),
+        });
+
+        assert_matches!(arr.get(&0, 0), Err(MapError::KeyNotFound));
+    }
+
+    #[test]
+    fn test_get_out_of_bounds() {
+        let map = new_map(new_obj_map());
+        let arr = ArrayOfMaps::<_, MapData>::new(&map).unwrap();
+
+        assert_matches!(arr.get(&1024, 0), Err(MapError::OutOfBounds { .. }));
+    }
+}
diff --git a/aya/src/maps/of_maps/hash_map.rs b/aya/src/maps/of_maps/hash_map.rs
new file mode 100644
index 000000000..15fb2d8dc
--- /dev/null
+++ b/aya/src/maps/of_maps/hash_map.rs
@@ -0,0 +1,284 @@
+//! A hash map of eBPF maps.
+
+use std::{
+    borrow::{Borrow, BorrowMut},
+    fmt,
+    marker::PhantomData,
+    os::fd::{AsFd as _, AsRawFd as _},
+    path::Path,
+};
+
+use crate::{
+    Pod,
+    maps::{FromMapData, InnerMap, MapData, MapError, MapKeys, PinError, check_kv_size, hash_map},
+    sys::{SyscallError, bpf_map_lookup_elem},
+};
+
+/// A hashmap of eBPF maps.
+///
+/// A `HashOfMaps` stores references to other eBPF maps, keyed by an arbitrary key type.
+///
+/// # Minimum kernel version
+///
+/// The minimum kernel version required to use this feature is 4.12.
+#[doc(alias = "BPF_MAP_TYPE_HASH_OF_MAPS")]
+pub struct HashOfMaps<T, K, V = MapData> {
+    pub(crate) inner: T,
+    _kv: PhantomData<(K, V)>,
+}
+
+impl<T: fmt::Debug, K, V> fmt::Debug for HashOfMaps<T, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HashOfMaps")
+            .field("inner", &self.inner)
+            .finish()
+    }
+}
+
+impl<T: Borrow<MapData>, K: Pod, V> HashOfMaps<T, K, V> {
+    pub(crate) fn new(map: T) -> Result<Self, MapError> {
+        let data = map.borrow();
+        check_kv_size::<K, u32>(data)?;
+
+        Ok(Self {
+            inner: map,
+            _kv: PhantomData,
+        })
+    }
+
+    /// An iterator visiting all keys in arbitrary order. The iterator element
+    /// type is `Result<K, MapError>`.
+    pub fn keys(&self) -> MapKeys<'_, K> {
+        MapKeys::new(self.inner.borrow())
+    }
+}
+
+impl<T: Borrow<MapData>, K: Pod, V: FromMapData> HashOfMaps<T, K, V> {
+    /// Returns the inner map associated with the key.
+    ///
+    /// The inner map type `V` is determined by the type parameter on the
+    /// `HashOfMaps` itself.
+    ///
+    /// # File descriptor cost
+    ///
+    /// Each call opens a **new file descriptor** to the inner map. The caller
+    /// owns the returned map and its FD is closed on drop. Avoid calling this
+    /// in a tight loop without dropping previous results.
+    pub fn get(&self, key: &K, flags: u64) -> Result<V, MapError> {
+        let fd = self.inner.borrow().fd().as_fd();
+        let value: Option<u32> =
+            bpf_map_lookup_elem(fd, key, flags).map_err(|io_error| SyscallError {
+                call: "bpf_map_lookup_elem",
+                io_error,
+            })?;
+        match value {
+            Some(id) => super::map_from_id(id),
+            None => Err(MapError::KeyNotFound),
+        }
+    }
+}
+
+impl<T: BorrowMut<MapData>, K: Pod, V: InnerMap> HashOfMaps<T, K, V> {
+    /// Inserts a key-value pair into the map.
+    pub fn insert(&mut self, key: impl Borrow<K>, value: &V, flags: u64) -> Result<(), MapError> {
+        hash_map::insert(
+            self.inner.borrow_mut(),
+            key.borrow(),
+            &value.fd().as_fd().as_raw_fd(),
+            flags,
+        )
+    }
+}
+
+impl<T: BorrowMut<MapData>, K: Pod, V> HashOfMaps<T, K, V> {
+    /// Removes a key from the map.
+    pub fn remove(&mut self, key: &K) -> Result<(), MapError> {
+        hash_map::remove(self.inner.borrow_mut(), key)
+    }
+}
+
+impl<K: Pod, V> HashOfMaps<MapData, K, V> {
+    /// Pins the map to a BPF filesystem.
+    ///
+    /// When a map is pinned it will remain loaded until the corresponding file
+    /// is deleted. All parent directories in the given `path` must already exist.
+    pub fn pin<P: AsRef<Path>>(self, path: P) -> Result<(), PinError> {
+        self.inner.pin(path)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io;
+
+    use assert_matches::assert_matches;
+    use aya_obj::generated::{bpf_cmd, bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS};
+    use libc::{EFAULT, ENOENT};
+
+    use super::*;
+    use crate::{
+        maps::{Map, test_utils},
+        sys::{SysResult, Syscall, override_syscall},
+    };
+
+    fn new_obj_map() -> aya_obj::Map {
+        test_utils::new_obj_map::<u32>(BPF_MAP_TYPE_HASH_OF_MAPS)
+    }
+
+    fn new_map(obj: aya_obj::Map) -> MapData {
+        test_utils::new_map(obj)
+    }
+
+    fn sys_error(value: i32) -> SysResult {
+        Err((-1, io::Error::from_raw_os_error(value)))
+    }
+
+    #[test]
+    fn test_wrong_key_size() {
+        let map = new_map(new_obj_map());
+        assert_matches!(
+            HashOfMaps::<_, u8>::new(&map),
+            Err(MapError::InvalidKeySize {
+                size: 1,
+                expected: 4
+            })
+        );
+    }
+
+    #[test]
+    fn test_try_from_wrong_map() {
+        let map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_HASH,
+        ));
+        let map = Map::HashMap(map);
+        assert_matches!(
+            HashOfMaps::<_, u32>::try_from(&map),
+            Err(MapError::InvalidMapType { .. })
+        );
+    }
+
+    #[test]
+    fn test_new_ok() {
+        let map = new_map(new_obj_map());
+        HashOfMaps::<_, u32>::new(&map).unwrap();
+    }
+
+    #[test]
+    fn test_insert_syscall_error() {
+        let mut map = new_map(new_obj_map());
+        let inner_map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_HASH,
+        ));
+        let mut hm = HashOfMaps::new(&mut map).unwrap();
+
+        override_syscall(|_| sys_error(EFAULT));
+
+        assert_matches!(
+            hm.insert(1u32, &inner_map, 0),
+            Err(MapError::SyscallError(SyscallError {
+                call: "bpf_map_update_elem",
+                ..
+            }))
+        );
+    }
+
+    #[test]
+    fn test_insert_ok() {
+        let mut map = new_map(new_obj_map());
+        let inner_map = new_map(test_utils::new_obj_map::<u32>(
+            aya_obj::generated::bpf_map_type::BPF_MAP_TYPE_HASH,
+        ));
+        let mut hm = HashOfMaps::new(&mut map).unwrap();
+
+        override_syscall(|call| match call {
+            Syscall::Ebpf {
+                cmd: bpf_cmd::BPF_MAP_UPDATE_ELEM,
+                ..
+            } => Ok(0),
+            _ => sys_error(EFAULT),
+        });
+
+        hm.insert(1u32, &inner_map, 0).unwrap();
+    }
+
+    #[test]
+    fn test_remove_syscall_error() {
+        let mut map = new_map(new_obj_map());
+        let mut hm = HashOfMaps::<_, u32>::new(&mut map).unwrap();
+
+        override_syscall(|_| sys_error(EFAULT));
+
+        assert_matches!(
+            hm.remove(&1u32),
+            Err(MapError::SyscallError(SyscallError {
+                call: "bpf_map_delete_elem",
+                ..
+            }))
+        );
+    }
+
+    #[test]
+    fn test_remove_ok() {
+        let mut map = new_map(new_obj_map());
+        let mut hm = HashOfMaps::<_, u32>::new(&mut map).unwrap();
+
+        override_syscall(|call| match call {
+            Syscall::Ebpf {
+                cmd: bpf_cmd::BPF_MAP_DELETE_ELEM,
+                ..
+            } => Ok(0),
+            _ => sys_error(EFAULT),
+        });
+
+        hm.remove(&1u32).unwrap();
+    }
+
+    #[test]
+    fn test_get_syscall_error() {
+        let map = new_map(new_obj_map());
+        let hm = HashOfMaps::<_, u32>::new(&map).unwrap();
+
+        override_syscall(|_| sys_error(EFAULT));
+
+        assert_matches!(
+            hm.get(&1u32, 0),
+            Err(MapError::SyscallError(SyscallError {
+                call: "bpf_map_lookup_elem",
+                ..
+            }))
+        );
+    }
+
+    #[test]
+    fn test_get_not_found() {
+        let map = new_map(new_obj_map());
+        let hm = HashOfMaps::<_, u32>::new(&map).unwrap();
+
+        override_syscall(|call| match call {
+            Syscall::Ebpf {
+                cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM,
+                ..
+            } => sys_error(ENOENT),
+            _ => sys_error(EFAULT),
+        });
+
+        assert_matches!(hm.get(&1u32, 0), Err(MapError::KeyNotFound));
+    }
+
+    #[test]
+    fn test_keys_empty() {
+        let map = new_map(new_obj_map());
+        let hm = HashOfMaps::<_, u32>::new(&map).unwrap();
+
+        override_syscall(|call| match call {
+            Syscall::Ebpf {
+                cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY,
+                ..
+            } => sys_error(ENOENT),
+            _ => sys_error(EFAULT),
+        });
+
+        let keys: Result<Vec<u32>, _> = hm.keys().collect();
+        assert_matches!(keys, Ok(ks) if ks.is_empty());
+    }
+}
diff --git a/aya/src/maps/of_maps/mod.rs b/aya/src/maps/of_maps/mod.rs
new file mode 100644
index 000000000..095737143
--- /dev/null
+++ b/aya/src/maps/of_maps/mod.rs
@@ -0,0 +1,18 @@
+//! Support for BPF maps that contain references to other maps.
+mod array;
+mod hash_map;
+
+pub use array::ArrayOfMaps;
+pub use hash_map::HashOfMaps;
+
+use super::{FromMapData, MapData, MapError};
+
+/// Converts a map ID returned by the kernel into a typed map.
+///
+/// The kernel's map-of-maps API is asymmetric: update takes the FD of the inner map,
+/// but lookup returns the ID. This helper converts the ID back to an FD and constructs
+/// the typed map via [`FromMapData`].
+fn map_from_id<M: FromMapData>(id: u32) -> Result<M, MapError> {
+    let map_data = MapData::from_id(id)?;
+    <M as FromMapData>::from_map_data(map_data)
+}
diff --git a/aya/src/maps/perf/perf_event_array.rs b/aya/src/maps/perf/perf_event_array.rs
index d992f3d96..cfc06ef7d 100644
--- a/aya/src/maps/perf/perf_event_array.rs
+++ b/aya/src/maps/perf/perf_event_array.rs
@@ -181,6 +181,10 @@ impl<T: Borrow<MapData>> PerfEventArray<T> {
         let data: &MapData = self.map.deref().borrow();
         data.pin(path)
     }
+
+    pub(crate) fn map_data(&self) -> &MapData {
+        self.map.deref().borrow()
+    }
 }
 
 impl<T: BorrowMut<MapData>> PerfEventArray<T> {
diff --git a/aya/src/maps/ring_buf.rs b/aya/src/maps/ring_buf.rs
index 94c8eda8c..c3d877555 100644
--- a/aya/src/maps/ring_buf.rs
+++ b/aya/src/maps/ring_buf.rs
@@ -109,6 +109,10 @@ impl<T: Borrow<MapData>> RingBuf<T> {
             producer,
         })
     }
+
+    pub(crate) fn map_data(&self) -> &MapData {
+        self.map.borrow()
+    }
 }
 
 impl<T> RingBuf<T> {
diff --git a/aya/src/sys/bpf.rs b/aya/src/sys/bpf.rs
index c9153ca4c..52ac8de92 100644
--- a/aya/src/sys/bpf.rs
+++ b/aya/src/sys/bpf.rs
@@ -51,6 +51,7 @@ pub(crate) fn bpf_create_map(
     name: &CStr,
     def: &aya_obj::Map,
     btf_fd: Option<BorrowedFd<'_>>,
+    inner_map_fd: Option<BorrowedFd<'_>>,
 ) -> io::Result<crate::MockableFd> {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
@@ -61,6 +62,11 @@ pub(crate) fn bpf_create_map(
     u.max_entries = def.max_entries();
     u.map_flags = def.map_flags();
 
+    // For map-of-maps types, set the inner_map_fd.
+    if let Some(inner_fd) = inner_map_fd {
+        u.inner_map_fd = inner_fd.as_raw_fd() as u32;
+    }
+
     if let aya_obj::Map::Btf(m) = def {
         // Mimic https://github.com/libbpf/libbpf/issues/355
         // Currently a bunch of (usually pretty specialized) BPF maps do not support
@@ -945,6 +951,7 @@ pub(crate) fn is_bpf_global_data_supported() -> bool {
                 max_entries: 1,
                 ..Default::default()
             },
+            inner_def: None,
             section_index: 0,
             section_kind: EbpfSectionKind::Maps,
             symbol_index: None,
diff --git a/ebpf/aya-ebpf/src/btf_maps/array_of_maps.rs b/ebpf/aya-ebpf/src/btf_maps/array_of_maps.rs
new file mode 100644
index 000000000..e5b3f3814
--- /dev/null
+++ b/ebpf/aya-ebpf/src/btf_maps/array_of_maps.rs
@@ -0,0 +1,49 @@
+use core::ptr::NonNull;
+
+use crate::{btf_maps::btf_map_def, lookup};
+
+btf_map_def!(
+    /// A BTF-compatible BPF map that stores references to other maps (array of maps).
+    ///
+    /// This map type allows you to store file descriptors of other BPF maps,
+    /// enabling dynamic map selection at runtime.
+    ///
+    /// # Minimum kernel version
+    ///
+    /// The minimum kernel version required to use this feature is 4.12.
+    ///
+    /// # Example
+    ///
+    /// ```rust,no_run
+    /// use aya_ebpf::{btf_maps::{Array, ArrayOfMaps}, macros::btf_map};
+    ///
+    /// // The inner map definition is parsed from BTF at load time.
+    /// #[btf_map]
+    /// static OUTER: ArrayOfMaps<Array<u32, 10>, 4> = ArrayOfMaps::new();
+    /// ```
+    pub struct ArrayOfMaps<V; const MAX_ENTRIES: usize, const FLAGS: usize = 0>,
+    map_type: BPF_MAP_TYPE_ARRAY_OF_MAPS,
+    max_entries: MAX_ENTRIES,
+    map_flags: FLAGS,
+    key_type: u32,
+    value_type: u32,
+    inner_map: V,
+);
+
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> ArrayOfMaps<V, MAX_ENTRIES, FLAGS> {
+    /// Retrieves a reference to the inner map at the given index.
+    ///
+    /// Returns `None` if the index is out of bounds or if no map is stored
+    /// at that index.
+    #[inline(always)]
+    pub fn get(&self, index: u32) -> Option<&V> {
+        // SAFETY: We only read from the map through BPF helpers.
+        // The struct fields are never accessed - only the address is used.
+        unsafe { self.lookup(index).map(|p| p.as_ref()) }
+    }
+
+    #[inline(always)]
+    unsafe fn lookup(&self, index: u32) -> Option<NonNull<V>> {
+        lookup(self.as_ptr(), &index)
+    }
+}
diff --git a/ebpf/aya-ebpf/src/btf_maps/hash_of_maps.rs b/ebpf/aya-ebpf/src/btf_maps/hash_of_maps.rs
new file mode 100644
index 000000000..a868b6cf3
--- /dev/null
+++ b/ebpf/aya-ebpf/src/btf_maps/hash_of_maps.rs
@@ -0,0 +1,53 @@
+use core::ptr::NonNull;
+
+use crate::{btf_maps::btf_map_def, lookup};
+
+btf_map_def!(
+    /// A BTF-compatible BPF hash map that stores references to other maps (hash of maps).
+    ///
+    /// This map type allows you to store file descriptors of other BPF maps
+    /// indexed by arbitrary keys, enabling dynamic map selection at runtime.
+    ///
+    /// # Minimum kernel version
+    ///
+    /// The minimum kernel version required to use this feature is 4.12.
+    ///
+    /// # Example
+    ///
+    /// ```rust,no_run
+    /// use aya_ebpf::{btf_maps::{Array, HashOfMaps}, macros::btf_map};
+    ///
+    /// // The inner map definition is parsed from BTF at load time.
+    /// #[btf_map]
+    /// static OUTER: HashOfMaps<u32, Array<u32, 10>, 4> = HashOfMaps::new();
+    /// ```
+    pub struct HashOfMaps<K, V; const MAX_ENTRIES: usize, const FLAGS: usize = 0>,
+    map_type: BPF_MAP_TYPE_HASH_OF_MAPS,
+    max_entries: MAX_ENTRIES,
+    map_flags: FLAGS,
+    key_type: K,
+    value_type: u32,
+    inner_map: V,
+);
+
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> HashOfMaps<K, V, MAX_ENTRIES, FLAGS> {
+    /// Retrieve the inner map associated with `key` from the map.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe. Unless the map flag `BPF_F_NO_PREALLOC` is used, the kernel does not
+    /// make guarantee on the atomicity of `insert` or `remove`, and any element removed from the
+    /// map might get aliased by another element in the map, causing garbage to be read, or
+    /// corruption in case of writes.
+    #[inline(always)]
+    pub unsafe fn get(&self, key: &K) -> Option<&V> {
+        // SAFETY: We only read from the map through BPF helpers.
+        // The struct fields are never accessed - only the address is used.
+        unsafe { self.lookup(key).map(|p| p.as_ref()) }
+    }
+
+    #[inline(always)]
+    unsafe fn lookup(&self, key: &K) -> Option<NonNull<V>> {
+        lookup(self.as_ptr(), key)
+    }
+}
diff --git a/ebpf/aya-ebpf/src/btf_maps/mod.rs b/ebpf/aya-ebpf/src/btf_maps/mod.rs
index b84e4a7f1..8eb50612e 100644
--- a/ebpf/aya-ebpf/src/btf_maps/mod.rs
+++ b/ebpf/aya-ebpf/src/btf_maps/mod.rs
@@ -1,8 +1,12 @@
 pub mod array;
+pub mod array_of_maps;
+pub mod hash_of_maps;
 pub mod ring_buf;
 pub mod sk_storage;
 
 pub use array::Array;
+pub use array_of_maps::ArrayOfMaps;
+pub use hash_of_maps::HashOfMaps;
 pub use ring_buf::RingBuf;
 pub use sk_storage::SkStorage;
 
@@ -18,7 +22,60 @@ pub use sk_storage::SkStorage;
 /// Generics are limited to type parameters (with optional defaults) followed by
 /// a semicolon and const parameters (with optional defaults). Lifetimes and
 /// bounds are not supported.
+///
+/// # Map-of-maps support
+///
+/// For map-of-maps types (`ArrayOfMaps`, `HashOfMaps`), add an `inner_map` clause:
+///
+/// ```ignore
+/// btf_map_def!(
+///     pub struct HashOfMaps<K, V; const MAX_ENTRIES: usize, const FLAGS: usize = 0>,
+///     map_type: BPF_MAP_TYPE_HASH_OF_MAPS,
+///     max_entries: MAX_ENTRIES,
+///     map_flags: FLAGS,
+///     key_type: K,
+///     value_type: u32,
+///     inner_map: V,
+/// );
+/// ```
+///
+/// This generates a `values: [*const V; 0]` field for BTF relocation. The inner
+/// map type `V` is encoded in BTF so that loaders can resolve the inner map
+/// template.
 macro_rules! btf_map_def {
+    // Map-of-maps (with inner_map) - rewrites into the regular arm with a
+    // `values` extra field whose initializer is `[]` (a zero-length array).
+    (
+        $(#[$attr:meta])*
+        $vis:vis struct $name:ident<
+            $($ty_gen:ident $(= $ty_default:ty)?),+
+            $(; $(const $const_gen:ident : $const_ty:ty $(= $const_default:tt)?),+)?
+            $(,)?
+        >,
+        map_type: $map_type:ident,
+        max_entries: $max_entries:expr,
+        map_flags: $map_flags:expr,
+        key_type: $key_ty:ty,
+        value_type: $value_ty:ty,
+        inner_map: $inner_ty:ty
+        $(,)?
+    ) => {
+        $crate::btf_maps::btf_map_def!(
+            $(#[$attr])*
+            $vis struct $name<
+                $($ty_gen $(= $ty_default)?),+
+                $(; $(const $const_gen : $const_ty $(= $const_default)?),+)?
+            >,
+            map_type: $map_type,
+            max_entries: $max_entries,
+            map_flags: $map_flags,
+            key_type: $key_ty,
+            value_type: $value_ty,
+            values: [*const $inner_ty; 0] = []
+        );
+    };
+
+    // Regular map (with optional extra fields and initializers)
     (
         $(#[$attr:meta])*
         $vis:vis struct $name:ident<
@@ -31,7 +88,7 @@ macro_rules! btf_map_def {
         map_flags: $map_flags:expr,
         key_type: $key_ty:ty,
         value_type: $value_ty:ty
-        $(, $extra_field:ident : $extra_ty:ty)*
+        $(, $extra_field:ident : $extra_ty:ty = $extra_init:expr)*
         $(,)?
     ) => {
         $(#[$attr])*
@@ -88,7 +145,7 @@ macro_rules! btf_map_def {
                     max_entries: ::core::ptr::null(),
                     map_flags: ::core::ptr::null(),
 
-                    $($extra_field: ::core::ptr::null(),)*
+                    $($extra_field: $extra_init,)*
                 }
             }
 
diff --git a/ebpf/aya-ebpf/src/btf_maps/ring_buf.rs b/ebpf/aya-ebpf/src/btf_maps/ring_buf.rs
index 219c68a11..0b6225fa6 100644
--- a/ebpf/aya-ebpf/src/btf_maps/ring_buf.rs
+++ b/ebpf/aya-ebpf/src/btf_maps/ring_buf.rs
@@ -18,7 +18,7 @@ btf_map_def!(
     map_flags: FLAGS,
     key_type: (),
     value_type: T,
-    value_size: *const [i32; 0],
+    value_size: *const [i32; 0] = ::core::ptr::null(),
 );
 
 impl<T, const MAX_ENTRIES: usize, const FLAGS: usize> RingBuf<T, MAX_ENTRIES, FLAGS> {
diff --git a/ebpf/aya-ebpf/src/maps/array.rs b/ebpf/aya-ebpf/src/maps/array.rs
index 05fc608e5..26b999061 100644
--- a/ebpf/aya-ebpf/src/maps/array.rs
+++ b/ebpf/aya-ebpf/src/maps/array.rs
@@ -12,6 +12,11 @@ pub struct Array<T> {
     _t: PhantomData<T>,
 }
 
+impl<T> super::private::Map for Array<T> {
+    type Key = u32;
+    type Value = T;
+}
+
 impl<T> Array<T> {
     map_constructors!(u32, T, BPF_MAP_TYPE_ARRAY, phantom _t);
 
diff --git a/ebpf/aya-ebpf/src/maps/array_of_maps.rs b/ebpf/aya-ebpf/src/maps/array_of_maps.rs
new file mode 100644
index 000000000..9fcd57d64
--- /dev/null
+++ b/ebpf/aya-ebpf/src/maps/array_of_maps.rs
@@ -0,0 +1,74 @@
+use core::{marker::PhantomData, ptr::NonNull};
+
+use aya_ebpf_cty::c_void;
+
+use crate::{
+    bindings::bpf_map_type::BPF_MAP_TYPE_ARRAY_OF_MAPS,
+    lookup,
+    maps::{Map, MapDef, PinningType},
+};
+
+/// An array of eBPF maps.
+///
+/// This map type stores references to other BPF maps, indexed by `u32` keys.
+/// It enables dynamic map selection at runtime based on an array index lookup.
+///
+/// # Differences from [`Array`](super::Array)
+///
+/// | Aspect         | `Array`          | `ArrayOfMaps`                      |
+/// |----------------|------------------|------------------------------------|
+/// | `value_size`   | `size_of::<T>()` | `size_of::<u32>()` (inner map fd)  |
+/// | BPF operations | get, set         | **get only** (kernel limitation)   |
+/// | Value type     | Any `T`          | Must impl `Map`                    |
+///
+/// # Minimum kernel version
+///
+/// The minimum kernel version required to use this feature is 4.12.
+#[repr(transparent)]
+pub struct ArrayOfMaps<T: Map> {
+    def: MapDef,
+    _t: PhantomData<T>,
+}
+
+impl<T: Map> ArrayOfMaps<T> {
+    map_constructors!(u32, u32, BPF_MAP_TYPE_ARRAY_OF_MAPS, phantom _t);
+
+    /// Retrieves a reference to the inner map at the given index.
+    ///
+    /// Returns `None` if the index is out of bounds or if no map is stored at that index.
+    #[inline(always)]
+    pub fn get(&self, index: u32) -> Option<&T> {
+        // SAFETY: The pointer returned by the BPF helper is valid for the
+        // duration of the program, and we only produce a shared reference.
+        unsafe { self.lookup(index).map(|p| p.as_ref()) }
+    }
+
+    #[inline(always)]
+    unsafe fn lookup(&self, index: u32) -> Option<NonNull<T>> {
+        lookup(self.def.as_ptr(), &index)
+    }
+
+    /// Looks up a value directly in the inner map at `outer_index`.
+    ///
+    /// Performs both the outer and inner `bpf_map_lookup_elem` calls in a
+    /// single method, producing fewer BPF instructions between the two
+    /// helpers. This reduces verifier state explosion in tight loops.
+    #[inline(always)]
+    pub fn get_value(&self, outer_index: u32, inner_key: &T::Key) -> Option<&T::Value> {
+        let inner: NonNull<c_void> = lookup(self.def.as_ptr(), &outer_index)?;
+        // SAFETY: Both pointers are returned by BPF helpers and are valid for
+        // the duration of the program. We only produce shared references.
+        unsafe { lookup::<T::Key, T::Value>(inner.as_ptr(), inner_key).map(|p| p.as_ref()) }
+    }
+
+    /// Same as [`get_value`](Self::get_value) but returns a mutable pointer.
+    #[inline(always)]
+    pub fn get_value_ptr_mut(&self, outer_index: u32, inner_key: &T::Key) -> Option<*mut T::Value> {
+        let inner: NonNull<c_void> = lookup(self.def.as_ptr(), &outer_index)?;
+        lookup::<T::Key, T::Value>(inner.as_ptr(), inner_key).map(NonNull::as_ptr)
+    }
+
+    // Note: set is intentionally not implemented.
+    // The kernel only allows bpf_map_lookup_elem on map-of-maps from BPF programs.
+    // Insert/update/delete operations are restricted to userspace via the syscall API.
+}
diff --git a/ebpf/aya-ebpf/src/maps/bloom_filter.rs b/ebpf/aya-ebpf/src/maps/bloom_filter.rs
index 93fc83c5c..23e5fa0f1 100644
--- a/ebpf/aya-ebpf/src/maps/bloom_filter.rs
+++ b/ebpf/aya-ebpf/src/maps/bloom_filter.rs
@@ -12,6 +12,11 @@ pub struct BloomFilter<T> {
     _t: PhantomData<T>,
 }
 
+impl<T> super::private::Map for BloomFilter<T> {
+    type Key = ();
+    type Value = T;
+}
+
 impl<T> BloomFilter<T> {
     map_constructors!((), T, BPF_MAP_TYPE_BLOOM_FILTER, phantom _t);
 
diff --git a/ebpf/aya-ebpf/src/maps/hash_map.rs b/ebpf/aya-ebpf/src/maps/hash_map.rs
index 705edee58..07fd751c4 100644
--- a/ebpf/aya-ebpf/src/maps/hash_map.rs
+++ b/ebpf/aya-ebpf/src/maps/hash_map.rs
@@ -16,6 +16,11 @@ macro_rules! define_hash_map {
             _kv: PhantomData<(K, V)>,
         }
 
+        impl<K, V> $crate::maps::private::Map for $name<K, V> {
+            type Key = K;
+            type Value = V;
+        }
+
         impl<K, V> $name<K, V> {
             pub const fn with_max_entries(max_entries: u32, flags: u32) -> Self {
                 Self::new(max_entries, flags, PinningType::None)
diff --git a/ebpf/aya-ebpf/src/maps/hash_of_maps.rs b/ebpf/aya-ebpf/src/maps/hash_of_maps.rs
new file mode 100644
index 000000000..4427cabc2
--- /dev/null
+++ b/ebpf/aya-ebpf/src/maps/hash_of_maps.rs
@@ -0,0 +1,89 @@
+use core::{marker::PhantomData, ptr::NonNull};
+
+use aya_ebpf_cty::c_void;
+
+use crate::{
+    bindings::bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS,
+    lookup,
+    maps::{Map, MapDef, PinningType},
+};
+
+/// A hash map of eBPF maps.
+///
+/// This map type stores references to other BPF maps, indexed by arbitrary keys.
+/// It enables dynamic map selection at runtime based on a hash key lookup.
+///
+/// # Differences from [`HashMap`](super::HashMap)
+///
+/// | Aspect         | `HashMap`           | `HashOfMaps`                       |
+/// |----------------|---------------------|------------------------------------|
+/// | `value_size`   | `size_of::<V>()`    | `size_of::<u32>()` (inner map fd)  |
+/// | BPF operations | get, insert, remove | **get only** (kernel limitation)   |
+/// | Value type     | Any `V`             | Must impl `Map`                    |
+///
+/// # Minimum kernel version
+///
+/// The minimum kernel version required to use this feature is 4.12.
+#[repr(transparent)]
+pub struct HashOfMaps<K, V: Map> {
+    def: MapDef,
+    _kv: PhantomData<(K, V)>,
+}
+
+impl<K, V: Map> HashOfMaps<K, V> {
+    map_constructors!(K, u32, BPF_MAP_TYPE_HASH_OF_MAPS, phantom _kv);
+
+    /// Retrieve the inner map associated with `key` from the map.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe. Unless the map flag `BPF_F_NO_PREALLOC` is used, the kernel does not
+    /// make guarantee on the atomicity of `insert` or `remove`, and any element removed from the
+    /// map might get aliased by another element in the map, causing garbage to be read, or
+    /// corruption in case of writes.
+    #[inline(always)]
+    pub unsafe fn get(&self, key: &K) -> Option<&V> {
+        // SAFETY: The pointer returned by the BPF helper is valid for the
+        // duration of the program, and we only produce a shared reference.
+        unsafe { self.lookup(key).map(|p| p.as_ref()) }
+    }
+
+    #[inline(always)]
+    unsafe fn lookup(&self, key: &K) -> Option<NonNull<V>> {
+        lookup(self.def.as_ptr(), key)
+    }
+
+    /// Looks up a value directly in the inner map associated with `outer_key`.
+    ///
+    /// Performs both the outer and inner `bpf_map_lookup_elem` calls in a
+    /// single method, producing fewer BPF instructions between the two
+    /// helpers. This reduces verifier state explosion in tight loops.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe for the same reasons as [`get`](Self::get).
+    #[inline(always)]
+    pub unsafe fn get_value(&self, outer_key: &K, inner_key: &V::Key) -> Option<&V::Value> {
+        let inner: NonNull<c_void> = lookup(self.def.as_ptr(), outer_key)?;
+        unsafe { lookup::<V::Key, V::Value>(inner.as_ptr(), inner_key).map(|p| p.as_ref()) }
+    }
+
+    /// Same as [`get_value`](Self::get_value) but returns a mutable pointer.
+    ///
+    /// # Safety
+    ///
+    /// See [`get_value`](Self::get_value).
+    #[inline(always)]
+    pub unsafe fn get_value_ptr_mut(
+        &self,
+        outer_key: &K,
+        inner_key: &V::Key,
+    ) -> Option<*mut V::Value> {
+        let inner: NonNull<c_void> = lookup(self.def.as_ptr(), outer_key)?;
+        lookup::<V::Key, V::Value>(inner.as_ptr(), inner_key).map(NonNull::as_ptr)
+    }
+
+    // Note: insert/remove are intentionally not implemented.
+    // The kernel only allows bpf_map_lookup_elem on map-of-maps from BPF programs.
+    // Insert/update/delete operations are restricted to userspace via the syscall API.
+}
diff --git a/ebpf/aya-ebpf/src/maps/lpm_trie.rs b/ebpf/aya-ebpf/src/maps/lpm_trie.rs
index d76a2bbee..6b61afdee 100644
--- a/ebpf/aya-ebpf/src/maps/lpm_trie.rs
+++ b/ebpf/aya-ebpf/src/maps/lpm_trie.rs
@@ -15,6 +15,11 @@ pub struct LpmTrie<K, V> {
     _kv: PhantomData<(K, V)>,
 }
 
+impl<K, V> super::private::Map for LpmTrie<K, V> {
+    type Key = Key<K>;
+    type Value = V;
+}
+
 #[repr(C, packed)]
 pub struct Key<K> {
     /// Represents the number of bits matched against.
diff --git a/ebpf/aya-ebpf/src/maps/mod.rs b/ebpf/aya-ebpf/src/maps/mod.rs
index ca0c732a8..bf86ecfff 100644
--- a/ebpf/aya-ebpf/src/maps/mod.rs
+++ b/ebpf/aya-ebpf/src/maps/mod.rs
@@ -17,6 +17,7 @@ pub(crate) mod def {
     unsafe impl Sync for MapDef {}
 
     impl MapDef {
+        /// Creates a new map definition with key type `K` and value type `V`.
         pub(crate) const fn new<K, V>(
             type_: u32,
             max_entries: u32,
@@ -76,8 +77,10 @@ macro_rules! map_constructors {
 }
 
 pub mod array;
+pub mod array_of_maps;
 pub mod bloom_filter;
 pub mod hash_map;
+pub mod hash_of_maps;
 pub mod lpm_trie;
 pub mod per_cpu_array;
 pub mod perf;
@@ -91,8 +94,10 @@ pub mod stack_trace;
 pub mod xdp;
 
 pub use array::Array;
+pub use array_of_maps::ArrayOfMaps;
 pub use bloom_filter::BloomFilter;
 pub use hash_map::{HashMap, LruHashMap, LruPerCpuHashMap, PerCpuHashMap};
+pub use hash_of_maps::HashOfMaps;
 pub use lpm_trie::LpmTrie;
 pub use per_cpu_array::PerCpuArray;
 pub use perf::{PerfEventArray, PerfEventByteArray};
@@ -104,3 +109,24 @@ pub use sock_map::SockMap;
 pub use stack::Stack;
 pub use stack_trace::StackTrace;
 pub use xdp::{CpuMap, DevMap, DevMapHash, XskMap};
+
+mod private {
+    /// Sealed trait to prevent external implementations of [`super::Map`].
+    #[expect(
+        unnameable_types,
+        reason = "sealed trait pattern requires pub trait in private mod"
+    )]
+    pub trait Map {
+        /// The key type declared in this map's definition.
+        type Key;
+        /// The value type declared in this map's definition.
+        type Value;
+    }
+}
+
+/// Marker trait for all eBPF maps that can be used in a map of maps.
+///
+/// This trait is sealed and cannot be implemented outside this crate.
+pub trait Map: private::Map {}
+
+impl<T: private::Map> Map for T {}
diff --git a/ebpf/aya-ebpf/src/maps/per_cpu_array.rs b/ebpf/aya-ebpf/src/maps/per_cpu_array.rs
index 82663ba60..61c972a4d 100644
--- a/ebpf/aya-ebpf/src/maps/per_cpu_array.rs
+++ b/ebpf/aya-ebpf/src/maps/per_cpu_array.rs
@@ -12,6 +12,11 @@ pub struct PerCpuArray<T> {
     _t: PhantomData<T>,
 }
 
+impl<T> super::private::Map for PerCpuArray<T> {
+    type Key = u32;
+    type Value = T;
+}
+
 impl<T> PerCpuArray<T> {
     map_constructors!(u32, T, BPF_MAP_TYPE_PERCPU_ARRAY, phantom _t);
 
diff --git a/ebpf/aya-ebpf/src/maps/queue.rs b/ebpf/aya-ebpf/src/maps/queue.rs
index 7ccc39c3f..e90d3fdcf 100644
--- a/ebpf/aya-ebpf/src/maps/queue.rs
+++ b/ebpf/aya-ebpf/src/maps/queue.rs
@@ -12,6 +12,11 @@ pub struct Queue<T> {
     _t: PhantomData<T>,
 }
 
+impl<T> super::private::Map for Queue<T> {
+    type Key = ();
+    type Value = T;
+}
+
 impl<T> Queue<T> {
     map_constructors!((), T, BPF_MAP_TYPE_QUEUE, phantom _t);
 
diff --git a/ebpf/aya-ebpf/src/maps/ring_buf.rs b/ebpf/aya-ebpf/src/maps/ring_buf.rs
index a4e5fb61a..f4fef557f 100644
--- a/ebpf/aya-ebpf/src/maps/ring_buf.rs
+++ b/ebpf/aya-ebpf/src/maps/ring_buf.rs
@@ -21,6 +21,11 @@ pub struct RingBuf {
     def: MapDef,
 }
 
+impl super::private::Map for RingBuf {
+    type Key = ();
+    type Value = ();
+}
+
 /// A ring buffer entry, returned from [`RingBuf::reserve_bytes`].
 ///
 /// You must [`submit`] or [`discard`] this entry before it gets dropped.
diff --git a/ebpf/aya-ebpf/src/maps/sock_hash.rs b/ebpf/aya-ebpf/src/maps/sock_hash.rs
index dea378ff3..33bb43e0a 100644
--- a/ebpf/aya-ebpf/src/maps/sock_hash.rs
+++ b/ebpf/aya-ebpf/src/maps/sock_hash.rs
@@ -22,6 +22,11 @@ pub struct SockHash<K> {
     _k: PhantomData<K>,
 }
 
+impl<K> super::private::Map for SockHash<K> {
+    type Key = K;
+    type Value = u32;
+}
+
 impl<K> SockHash<K> {
     map_constructors!(K, u32, BPF_MAP_TYPE_SOCKHASH, phantom _k);
 
diff --git a/ebpf/aya-ebpf/src/maps/sock_map.rs b/ebpf/aya-ebpf/src/maps/sock_map.rs
index 2bac36c38..b47aafb04 100644
--- a/ebpf/aya-ebpf/src/maps/sock_map.rs
+++ b/ebpf/aya-ebpf/src/maps/sock_map.rs
@@ -15,6 +15,11 @@ pub struct SockMap {
     def: MapDef,
 }
 
+impl super::private::Map for SockMap {
+    type Key = u32;
+    type Value = u32;
+}
+
 impl SockMap {
     map_constructors!(u32, u32, BPF_MAP_TYPE_SOCKMAP);
 
diff --git a/ebpf/aya-ebpf/src/maps/stack.rs b/ebpf/aya-ebpf/src/maps/stack.rs
index 424c5e570..e777bfa1e 100644
--- a/ebpf/aya-ebpf/src/maps/stack.rs
+++ b/ebpf/aya-ebpf/src/maps/stack.rs
@@ -12,6 +12,11 @@ pub struct Stack<T> {
     _t: PhantomData<T>,
 }
 
+impl<T> super::private::Map for Stack<T> {
+    type Key = ();
+    type Value = T;
+}
+
 impl<T> Stack<T> {
     map_constructors!((), T, BPF_MAP_TYPE_STACK, phantom _t);
 
diff --git a/ebpf/aya-ebpf/src/maps/stack_trace.rs b/ebpf/aya-ebpf/src/maps/stack_trace.rs
index 06da826d0..627f5ef94 100644
--- a/ebpf/aya-ebpf/src/maps/stack_trace.rs
+++ b/ebpf/aya-ebpf/src/maps/stack_trace.rs
@@ -12,6 +12,11 @@ pub struct StackTrace {
     def: MapDef,
 }
 
+impl super::private::Map for StackTrace {
+    type Key = u32;
+    type Value = [u64; PERF_MAX_STACK_DEPTH];
+}
+
 const PERF_MAX_STACK_DEPTH: usize = 127;
 
 impl StackTrace {
diff --git a/ebpf/aya-ebpf/src/maps/xdp/cpu_map.rs b/ebpf/aya-ebpf/src/maps/xdp/cpu_map.rs
index df85c42e7..bccf12d6e 100644
--- a/ebpf/aya-ebpf/src/maps/xdp/cpu_map.rs
+++ b/ebpf/aya-ebpf/src/maps/xdp/cpu_map.rs
@@ -33,6 +33,11 @@ pub struct CpuMap {
     def: MapDef,
 }
 
+impl super::super::private::Map for CpuMap {
+    type Key = u32;
+    type Value = bpf_cpumap_val;
+}
+
 impl CpuMap {
     map_constructors!(
         u32,
diff --git a/ebpf/aya-ebpf/src/maps/xdp/dev_map.rs b/ebpf/aya-ebpf/src/maps/xdp/dev_map.rs
index 68b38fa64..c05920a11 100644
--- a/ebpf/aya-ebpf/src/maps/xdp/dev_map.rs
+++ b/ebpf/aya-ebpf/src/maps/xdp/dev_map.rs
@@ -35,6 +35,11 @@ pub struct DevMap {
     def: MapDef,
 }
 
+impl super::super::private::Map for DevMap {
+    type Key = u32;
+    type Value = bpf_devmap_val;
+}
+
 impl DevMap {
     map_constructors!(
         u32,
diff --git a/ebpf/aya-ebpf/src/maps/xdp/dev_map_hash.rs b/ebpf/aya-ebpf/src/maps/xdp/dev_map_hash.rs
index 1ab835388..2f9a7845f 100644
--- a/ebpf/aya-ebpf/src/maps/xdp/dev_map_hash.rs
+++ b/ebpf/aya-ebpf/src/maps/xdp/dev_map_hash.rs
@@ -37,6 +37,11 @@ pub struct DevMapHash {
     def: MapDef,
 }
 
+impl super::super::private::Map for DevMapHash {
+    type Key = u32;
+    type Value = bpf_devmap_val;
+}
+
 impl DevMapHash {
     map_constructors!(
         u32,
diff --git a/ebpf/aya-ebpf/src/maps/xdp/xsk_map.rs b/ebpf/aya-ebpf/src/maps/xdp/xsk_map.rs
index 8909d7e39..67b8ddcc5 100644
--- a/ebpf/aya-ebpf/src/maps/xdp/xsk_map.rs
+++ b/ebpf/aya-ebpf/src/maps/xdp/xsk_map.rs
@@ -54,6 +54,11 @@ pub struct XskMap {
     def: MapDef,
 }
 
+impl super::super::private::Map for XskMap {
+    type Key = u32;
+    type Value = u32;
+}
+
 impl XskMap {
     map_constructors!(
         u32,
diff --git a/test/integration-ebpf/Cargo.toml b/test/integration-ebpf/Cargo.toml
index 185c37c39..524e2b1ab 100644
--- a/test/integration-ebpf/Cargo.toml
+++ b/test/integration-ebpf/Cargo.toml
@@ -115,3 +115,11 @@ path = "src/uprobe_cookie.rs"
 [[bin]]
 name = "perf_event_bp"
 path = "src/perf_event_bp.rs"
+
+[[bin]]
+name = "map_of_maps"
+path = "src/map_of_maps.rs"
+
+[[bin]]
+name = "btf_map_of_maps"
+path = "src/btf_map_of_maps.rs"
diff --git a/test/integration-ebpf/src/btf_map_of_maps.rs b/test/integration-ebpf/src/btf_map_of_maps.rs
new file mode 100644
index 000000000..8265f3ad3
--- /dev/null
+++ b/test/integration-ebpf/src/btf_map_of_maps.rs
@@ -0,0 +1,56 @@
+#![no_std]
+#![no_main]
+#![expect(unused_crate_dependencies, reason = "used in other bins")]
+
+//! BTF-compatible map-of-maps test.
+//!
+//! This test uses the BTF map definitions which should be compatible
+//! with libbpf loaders.
+
+use aya_ebpf::{
+    btf_maps::{Array, ArrayOfMaps},
+    macros::{btf_map, uprobe},
+    programs::ProbeContext,
+};
+
+#[cfg(not(test))]
+extern crate ebpf_panic;
+
+// The inner map definition is parsed from the BTF `values` field at load time.
+#[btf_map]
+static OUTER: ArrayOfMaps<Array<u32, 10>, 4> = ArrayOfMaps::new();
+
+// Result array to verify values from userspace.
+#[btf_map]
+static RESULTS: Array<u32, 4> = Array::new();
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+#[expect(
+    clippy::missing_const_for_fn,
+    reason = "extern functions cannot be const"
+)]
+pub extern "C" fn trigger_btf_map_of_maps() {
+    core::hint::black_box(());
+}
+
+/// Reads a value from an inner array selected via the outer map and stores the result.
+#[uprobe]
+pub(crate) fn test_btf_array_of_maps(_ctx: ProbeContext) -> u32 {
+    if let Some(inner) = OUTER.get(0) {
+        if let Some(val) = inner.get(0) {
+            if let Some(ptr) = RESULTS.get_ptr_mut(0) {
+                unsafe {
+                    *ptr = *val;
+                }
+            }
+        }
+    }
+    // Mark test ran.
+    if let Some(ptr) = RESULTS.get_ptr_mut(1) {
+        unsafe {
+            *ptr = 1;
+        }
+    }
+    0
+}
diff --git a/test/integration-ebpf/src/map_of_maps.rs b/test/integration-ebpf/src/map_of_maps.rs
new file mode 100644
index 000000000..ed224cf66
--- /dev/null
+++ b/test/integration-ebpf/src/map_of_maps.rs
@@ -0,0 +1,169 @@
+#![no_std]
+#![no_main]
+#![expect(unused_crate_dependencies, reason = "used in other bins")]
+
+use aya_ebpf::{
+    macros::{map, uprobe},
+    maps::{Array, ArrayOfMaps, HashMap, HashOfMaps},
+    programs::ProbeContext,
+};
+#[cfg(not(test))]
+extern crate ebpf_panic;
+
+// ArrayOfMaps test maps - explicitly bind to INNER_ARRAY_1 as template.
+#[map(inner = "INNER_ARRAY_1")]
+static ARRAY_OF_MAPS: ArrayOfMaps<Array<u32>> = ArrayOfMaps::with_max_entries(2, 0);
+
+#[map]
+static INNER_ARRAY_1: Array<u32> = Array::with_max_entries(10, 0);
+
+#[map]
+static INNER_ARRAY_2: Array<u32> = Array::with_max_entries(10, 0);
+
+// HashOfMaps test maps - explicitly bind to INNER_HASH_1 as template.
+#[map(inner = "INNER_HASH_1")]
+static HASH_OF_MAPS: HashOfMaps<u32, HashMap<u32, u32>> = HashOfMaps::with_max_entries(2, 0);
+
+#[map]
+static INNER_HASH_1: HashMap<u32, u32> = HashMap::with_max_entries(10, 0);
+
+#[map]
+static INNER_HASH_2: HashMap<u32, u32> = HashMap::with_max_entries(10, 0);
+
+// Result array to verify values from userspace.
+#[map]
+static RESULTS: Array<u32> = Array::with_max_entries(4, 0);
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+#[expect(
+    clippy::missing_const_for_fn,
+    reason = "extern functions cannot be const"
+)]
+pub extern "C" fn trigger_array_of_maps() {
+    core::hint::black_box(());
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+#[expect(
+    clippy::missing_const_for_fn,
+    reason = "extern functions cannot be const"
+)]
+pub extern "C" fn trigger_hash_of_maps() {
+    core::hint::black_box(());
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+#[expect(
+    clippy::missing_const_for_fn,
+    reason = "extern functions cannot be const"
+)]
+pub extern "C" fn trigger_array_of_maps_get_value() {
+    core::hint::black_box(());
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+#[expect(
+    clippy::missing_const_for_fn,
+    reason = "extern functions cannot be const"
+)]
+pub extern "C" fn trigger_hash_of_maps_get_value() {
+    core::hint::black_box(());
+}
+
+/// Test `ArrayOfMaps`: write values to inner arrays via outer map.
+#[uprobe]
+pub(crate) fn test_array_of_maps(_ctx: ProbeContext) -> u32 {
+    // Access first inner map (index 0) and write value
+    if let Some(map) = ARRAY_OF_MAPS.get(0) {
+        if let Some(ptr) = map.get_ptr_mut(0) {
+            unsafe {
+                *ptr = 42;
+            }
+        }
+    }
+
+    // Access second inner map (index 1) and write value
+    if let Some(map) = ARRAY_OF_MAPS.get(1) {
+        if let Some(ptr) = map.get_ptr_mut(0) {
+            unsafe {
+                *ptr = 24;
+            }
+        }
+    }
+
+    // Store results for verification
+    if let Some(ptr) = RESULTS.get_ptr_mut(0) {
+        unsafe {
+            *ptr = 1;
+        } // Mark test ran
+    }
+
+    0
+}
+
+/// Test `HashOfMaps`: write values to inner hashmaps via outer map.
+#[uprobe]
+pub(crate) fn test_hash_of_maps(_ctx: ProbeContext) -> u32 {
+    // Access first inner map (key 0) and write value
+    if let Some(map) = unsafe { HASH_OF_MAPS.get(&0u32) } {
+        _ = map.insert(100u32, 42u32, 0);
+    }
+
+    // Access second inner map (key 1) and write value
+    if let Some(map) = unsafe { HASH_OF_MAPS.get(&1u32) } {
+        _ = map.insert(100u32, 24u32, 0);
+    }
+
+    // Store results for verification
+    if let Some(ptr) = RESULTS.get_ptr_mut(1) {
+        unsafe {
+            *ptr = 1;
+        } // Mark test ran
+    }
+
+    0
+}
+
+/// Test `ArrayOfMaps::get_value` and `get_value_ptr_mut`.
+#[uprobe]
+pub(crate) fn test_array_of_maps_get_value(_ctx: ProbeContext) -> u32 {
+    if let Some(val) = ARRAY_OF_MAPS.get_value(0, &0u32) {
+        if let Some(ptr) = RESULTS.get_ptr_mut(2) {
+            unsafe {
+                *ptr = *val;
+            }
+        }
+    }
+
+    if let Some(ptr) = ARRAY_OF_MAPS.get_value_ptr_mut(1, &0u32) {
+        unsafe {
+            *ptr = 99;
+        }
+    }
+
+    0
+}
+
+/// Test `HashOfMaps::get_value` and `get_value_ptr_mut`.
+#[uprobe]
+pub(crate) fn test_hash_of_maps_get_value(_ctx: ProbeContext) -> u32 {
+    if let Some(val) = unsafe { HASH_OF_MAPS.get_value(&0u32, &100u32) } {
+        if let Some(ptr) = RESULTS.get_ptr_mut(3) {
+            unsafe {
+                *ptr = *val;
+            }
+        }
+    }
+
+    if let Some(ptr) = unsafe { HASH_OF_MAPS.get_value_ptr_mut(&1u32, &200u32) } {
+        unsafe {
+            *ptr = 88;
+        }
+    }
+
+    0
+}
diff --git a/test/integration-test/src/lib.rs b/test/integration-test/src/lib.rs
index 702c71908..e0cfdbce3 100644
--- a/test/integration-test/src/lib.rs
+++ b/test/integration-test/src/lib.rs
@@ -62,6 +62,8 @@ bpf_file!(
     TWO_PROGS => "two_progs",
     XDP_SEC => "xdp_sec",
     UPROBE_COOKIE => "uprobe_cookie",
+    MAP_OF_MAPS => "map_of_maps",
+    BTF_MAP_OF_MAPS => "btf_map_of_maps",
 );
 
 #[cfg(test)]
diff --git a/test/integration-test/src/tests.rs b/test/integration-test/src/tests.rs
index 098c79551..17d365097 100644
--- a/test/integration-test/src/tests.rs
+++ b/test/integration-test/src/tests.rs
@@ -21,6 +21,7 @@ mod linear_data_structures;
 mod load;
 mod log;
 mod lsm;
+mod map_of_maps;
 mod map_pin;
 mod maps_disjoint;
 mod perf_event_bp;
diff --git a/test/integration-test/src/tests/map_of_maps.rs b/test/integration-test/src/tests/map_of_maps.rs
new file mode 100644
index 000000000..a292019b2
--- /dev/null
+++ b/test/integration-test/src/tests/map_of_maps.rs
@@ -0,0 +1,289 @@
+use aya::{
+    Ebpf,
+    maps::{Array, ArrayOfMaps, HashMap, HashOfMaps, MapData, MapFd},
+    programs::UProbe,
+};
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+extern "C" fn trigger_array_of_maps() {
+    std::hint::black_box(());
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+extern "C" fn trigger_hash_of_maps() {
+    std::hint::black_box(());
+}
+
+/// Test `ArrayOfMaps`: set inner maps and verify eBPF can access them.
+#[test_log::test]
+fn array_of_maps() {
+    let mut ebpf = Ebpf::load(crate::MAP_OF_MAPS).unwrap();
+
+    // Clone the inner map FDs to avoid borrow conflicts
+    let inner_array_1_fd = ebpf.map("INNER_ARRAY_1").unwrap().fd().try_clone().unwrap();
+    let inner_array_2_fd = ebpf.map("INNER_ARRAY_2").unwrap().fd().try_clone().unwrap();
+
+    // Set inner maps into the outer ArrayOfMaps
+    {
+        let mut outer: ArrayOfMaps<&mut MapData, MapFd> =
+            ebpf.map_mut("ARRAY_OF_MAPS").unwrap().try_into().unwrap();
+        outer.set(0, &inner_array_1_fd, 0).unwrap();
+        outer.set(1, &inner_array_2_fd, 0).unwrap();
+    }
+
+    // Load and attach the uprobe
+    {
+        let prog: &mut UProbe = ebpf
+            .program_mut("test_array_of_maps")
+            .unwrap()
+            .try_into()
+            .unwrap();
+        prog.load().unwrap();
+        prog.attach("trigger_array_of_maps", "/proc/self/exe", None)
+            .unwrap();
+    }
+
+    // Trigger the probe
+    trigger_array_of_maps();
+
+    // Verify the eBPF program wrote to the inner maps
+    let inner_1: Array<&MapData, u32> = ebpf.map("INNER_ARRAY_1").unwrap().try_into().unwrap();
+    let inner_2: Array<&MapData, u32> = ebpf.map("INNER_ARRAY_2").unwrap().try_into().unwrap();
+
+    assert_eq!(inner_1.get(&0, 0).unwrap(), 42);
+    assert_eq!(inner_2.get(&0, 0).unwrap(), 24);
+
+    // Verify the results array was updated
+    let results: Array<&MapData, u32> = ebpf.map("RESULTS").unwrap().try_into().unwrap();
+    assert_eq!(results.get(&0, 0).unwrap(), 1);
+}
+
+/// Test `HashOfMaps`: set inner maps and verify eBPF can access them.
+#[test_log::test]
+fn hash_of_maps() {
+    let mut ebpf = Ebpf::load(crate::MAP_OF_MAPS).unwrap();
+
+    // Clone the inner map FDs to avoid borrow conflicts
+    let inner_hash_1_fd = ebpf.map("INNER_HASH_1").unwrap().fd().try_clone().unwrap();
+    let inner_hash_2_fd = ebpf.map("INNER_HASH_2").unwrap().fd().try_clone().unwrap();
+
+    // Set inner maps into the outer HashOfMaps
+    {
+        let mut outer: HashOfMaps<&mut MapData, u32, MapFd> =
+            ebpf.map_mut("HASH_OF_MAPS").unwrap().try_into().unwrap();
+        outer.insert(0u32, &inner_hash_1_fd, 0).unwrap();
+        outer.insert(1u32, &inner_hash_2_fd, 0).unwrap();
+    }
+
+    // Load and attach the uprobe
+    {
+        let prog: &mut UProbe = ebpf
+            .program_mut("test_hash_of_maps")
+            .unwrap()
+            .try_into()
+            .unwrap();
+        prog.load().unwrap();
+        prog.attach("trigger_hash_of_maps", "/proc/self/exe", None)
+            .unwrap();
+    }
+
+    // Trigger the probe
+    trigger_hash_of_maps();
+
+    // Verify the eBPF program wrote to the inner maps
+    let inner_1: HashMap<&MapData, u32, u32> =
+        ebpf.map("INNER_HASH_1").unwrap().try_into().unwrap();
+    let inner_2: HashMap<&MapData, u32, u32> =
+        ebpf.map("INNER_HASH_2").unwrap().try_into().unwrap();
+
+    assert_eq!(inner_1.get(&100, 0).unwrap(), 42);
+    assert_eq!(inner_2.get(&100, 0).unwrap(), 24);
+
+    // Verify the results array was updated
+    let results: Array<&MapData, u32> = ebpf.map("RESULTS").unwrap().try_into().unwrap();
+    assert_eq!(results.get(&1, 0).unwrap(), 1);
+}
+
+/// Test dynamic inner map creation: create inner maps programmatically and use them with `HashOfMaps`.
+#[test_log::test]
+fn hash_of_maps_dynamic() {
+    let mut ebpf = Ebpf::load(crate::MAP_OF_MAPS).unwrap();
+
+    // Create inner maps dynamically with the same max_entries as the template (10)
+    // Note: max_entries must match the template used when creating the outer map
+    let mut inner_1: HashMap<MapData, u32, u32> = HashMap::create(10, 0).unwrap();
+    let mut inner_2: HashMap<MapData, u32, u32> = HashMap::create(10, 0).unwrap();
+
+    // Pre-populate the dynamic inner maps with some data
+    inner_1.insert(100u32, 1000u32, 0).unwrap();
+    inner_2.insert(100u32, 2000u32, 0).unwrap();
+
+    // Insert the dynamically created inner maps into the outer HashOfMaps
+    {
+        let mut outer: HashOfMaps<&mut MapData, u32, HashMap<MapData, u32, u32>> =
+            ebpf.map_mut("HASH_OF_MAPS").unwrap().try_into().unwrap();
+        // Use keys 10 and 11 to avoid conflict with the other test
+        outer.insert(10u32, &inner_1, 0).unwrap();
+        outer.insert(11u32, &inner_2, 0).unwrap();
+    }
+
+    // Verify we can still read from the dynamically created inner maps
+    assert_eq!(inner_1.get(&100, 0).unwrap(), 1000);
+    assert_eq!(inner_2.get(&100, 0).unwrap(), 2000);
+
+    // Modify the inner maps and verify changes persist
+    inner_1.insert(200u32, 3000u32, 0).unwrap();
+    assert_eq!(inner_1.get(&200, 0).unwrap(), 3000);
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+extern "C" fn trigger_array_of_maps_get_value() {
+    std::hint::black_box(());
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+extern "C" fn trigger_hash_of_maps_get_value() {
+    std::hint::black_box(());
+}
+
+/// Test `ArrayOfMaps::get_value` and `get_value_ptr_mut`.
+#[test_log::test]
+fn array_of_maps_get_value() {
+    let mut ebpf = Ebpf::load(crate::MAP_OF_MAPS).unwrap();
+
+    // The eBPF program reads inner_1[0] via get_value and writes inner_2[0] via get_value_ptr_mut.
+    {
+        let mut inner_1: Array<&mut MapData, u32> =
+            ebpf.map_mut("INNER_ARRAY_1").unwrap().try_into().unwrap();
+        inner_1.set(0, 77u32, 0).unwrap();
+    }
+    {
+        let mut inner_2: Array<&mut MapData, u32> =
+            ebpf.map_mut("INNER_ARRAY_2").unwrap().try_into().unwrap();
+        inner_2.set(0, 0u32, 0).unwrap();
+    }
+
+    let inner_array_1_fd = ebpf.map("INNER_ARRAY_1").unwrap().fd().try_clone().unwrap();
+    let inner_array_2_fd = ebpf.map("INNER_ARRAY_2").unwrap().fd().try_clone().unwrap();
+
+    {
+        let mut outer: ArrayOfMaps<&mut MapData, MapFd> =
+            ebpf.map_mut("ARRAY_OF_MAPS").unwrap().try_into().unwrap();
+        outer.set(0, &inner_array_1_fd, 0).unwrap();
+        outer.set(1, &inner_array_2_fd, 0).unwrap();
+    }
+
+    {
+        let prog: &mut UProbe = ebpf
+            .program_mut("test_array_of_maps_get_value")
+            .unwrap()
+            .try_into()
+            .unwrap();
+        prog.load().unwrap();
+        prog.attach("trigger_array_of_maps_get_value", "/proc/self/exe", None)
+            .unwrap();
+    }
+
+    trigger_array_of_maps_get_value();
+
+    let results: Array<&MapData, u32> = ebpf.map("RESULTS").unwrap().try_into().unwrap();
+    assert_eq!(results.get(&2, 0).unwrap(), 77);
+
+    let inner_2: Array<&MapData, u32> = ebpf.map("INNER_ARRAY_2").unwrap().try_into().unwrap();
+    assert_eq!(inner_2.get(&0, 0).unwrap(), 99);
+}
+
+/// Test `HashOfMaps::get_value` and `get_value_ptr_mut`.
+#[test_log::test]
+fn hash_of_maps_get_value() {
+    let mut ebpf = Ebpf::load(crate::MAP_OF_MAPS).unwrap();
+
+    // The eBPF program reads inner_1[100] via get_value and writes inner_2[200] via get_value_ptr_mut.
+    {
+        let mut inner_1: HashMap<&mut MapData, u32, u32> =
+            ebpf.map_mut("INNER_HASH_1").unwrap().try_into().unwrap();
+        inner_1.insert(100u32, 55u32, 0).unwrap();
+    }
+    {
+        let mut inner_2: HashMap<&mut MapData, u32, u32> =
+            ebpf.map_mut("INNER_HASH_2").unwrap().try_into().unwrap();
+        inner_2.insert(200u32, 0u32, 0).unwrap();
+    }
+
+    let inner_hash_1_fd = ebpf.map("INNER_HASH_1").unwrap().fd().try_clone().unwrap();
+    let inner_hash_2_fd = ebpf.map("INNER_HASH_2").unwrap().fd().try_clone().unwrap();
+
+    {
+        let mut outer: HashOfMaps<&mut MapData, u32, MapFd> =
+            ebpf.map_mut("HASH_OF_MAPS").unwrap().try_into().unwrap();
+        outer.insert(0u32, &inner_hash_1_fd, 0).unwrap();
+        outer.insert(1u32, &inner_hash_2_fd, 0).unwrap();
+    }
+
+    {
+        let prog: &mut UProbe = ebpf
+            .program_mut("test_hash_of_maps_get_value")
+            .unwrap()
+            .try_into()
+            .unwrap();
+        prog.load().unwrap();
+        prog.attach("trigger_hash_of_maps_get_value", "/proc/self/exe", None)
+            .unwrap();
+    }
+
+    trigger_hash_of_maps_get_value();
+
+    let results: Array<&MapData, u32> = ebpf.map("RESULTS").unwrap().try_into().unwrap();
+    assert_eq!(results.get(&3, 0).unwrap(), 55);
+
+    let inner_2: HashMap<&MapData, u32, u32> =
+        ebpf.map("INNER_HASH_2").unwrap().try_into().unwrap();
+    assert_eq!(inner_2.get(&200, 0).unwrap(), 88);
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+extern "C" fn trigger_btf_map_of_maps() {
+    std::hint::black_box(());
+}
+
+/// Test BTF-based `ArrayOfMaps`: inner map definition is parsed from BTF `values` field.
+#[test_log::test]
+fn btf_array_of_maps() {
+    let mut ebpf = Ebpf::load(crate::BTF_MAP_OF_MAPS).unwrap();
+
+    // Create a dynamic inner Array matching the BTF inner definition (Array<u32, 10>).
+    let mut inner_array: Array<MapData, u32> = Array::create(10, 0).unwrap();
+    inner_array.set(0, 42u32, 0).unwrap();
+
+    // Insert the inner array into the outer ArrayOfMaps at index 0.
+    {
+        let mut outer: ArrayOfMaps<&mut MapData, Array<MapData, u32>> =
+            ebpf.map_mut("OUTER").unwrap().try_into().unwrap();
+        outer.set(0, &inner_array, 0).unwrap();
+    }
+
+    // Load and attach the uprobe.
+    {
+        let prog: &mut UProbe = ebpf
+            .program_mut("test_btf_array_of_maps")
+            .unwrap()
+            .try_into()
+            .unwrap();
+        prog.load().unwrap();
+        prog.attach("trigger_btf_map_of_maps", "/proc/self/exe", None)
+            .unwrap();
+    }
+
+    // Trigger the probe.
+    trigger_btf_map_of_maps();
+
+    // Verify the eBPF program read from the inner map and wrote to RESULTS.
+    let results: Array<&MapData, u32> = ebpf.map("RESULTS").unwrap().try_into().unwrap();
+    assert_eq!(results.get(&0, 0).unwrap(), 42);
+    assert_eq!(results.get(&1, 0).unwrap(), 1);
+}
diff --git a/xtask/public-api/aya-ebpf.txt b/xtask/public-api/aya-ebpf.txt
index a5d1de27b..8569bae0e 100644
--- a/xtask/public-api/aya-ebpf.txt
+++ b/xtask/public-api/aya-ebpf.txt
@@ -39,6 +39,68 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::array::Array<T, MAX_E
 pub fn aya_ebpf::btf_maps::array::Array<T, MAX_ENTRIES, FLAGS>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::btf_maps::array::Array<T, MAX_ENTRIES, FLAGS>
 pub fn aya_ebpf::btf_maps::array::Array<T, MAX_ENTRIES, FLAGS>::from(t: T) -> T
+pub mod aya_ebpf::btf_maps::array_of_maps
+#[repr(C)] pub struct aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, const MAX_ENTRIES: usize, const FLAGS: usize>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::get(&self, index: u32) -> core::option::Option<&V>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub const fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::new() -> Self
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::default::Default for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::default() -> Self
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Sync for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Freeze for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> !core::marker::Send for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Unpin for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::UnsafeUnpin for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::from(t: T) -> T
+pub mod aya_ebpf::btf_maps::hash_of_maps
+#[repr(C)] pub struct aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, const MAX_ENTRIES: usize, const FLAGS: usize>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub unsafe fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::get(&self, key: &K) -> core::option::Option<&V>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub const fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::new() -> Self
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::default::Default for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::default() -> Self
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Sync for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Freeze for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> !core::marker::Send for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Unpin for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::UnsafeUnpin for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::from(t: T) -> T
 pub mod aya_ebpf::btf_maps::ring_buf
 #[repr(C)] pub struct aya_ebpf::btf_maps::ring_buf::RingBuf<T, const MAX_ENTRIES: usize, const FLAGS: usize>
 impl<T, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::ring_buf::RingBuf<T, MAX_ENTRIES, FLAGS>
@@ -140,6 +202,66 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::array::Array<T, MAX_E
 pub fn aya_ebpf::btf_maps::array::Array<T, MAX_ENTRIES, FLAGS>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::btf_maps::array::Array<T, MAX_ENTRIES, FLAGS>
 pub fn aya_ebpf::btf_maps::array::Array<T, MAX_ENTRIES, FLAGS>::from(t: T) -> T
+#[repr(C)] pub struct aya_ebpf::btf_maps::ArrayOfMaps<V, const MAX_ENTRIES: usize, const FLAGS: usize>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::get(&self, index: u32) -> core::option::Option<&V>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub const fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::new() -> Self
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::default::Default for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::default() -> Self
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Sync for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Freeze for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> !core::marker::Send for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Unpin for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::UnsafeUnpin for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::array_of_maps::ArrayOfMaps<V, MAX_ENTRIES, FLAGS>::from(t: T) -> T
+#[repr(C)] pub struct aya_ebpf::btf_maps::HashOfMaps<K, V, const MAX_ENTRIES: usize, const FLAGS: usize>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub unsafe fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::get(&self, key: &K) -> core::option::Option<&V>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub const fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::new() -> Self
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::default::Default for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::default() -> Self
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Sync for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Freeze for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> !core::marker::Send for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::Unpin for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::marker::UnsafeUnpin for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<K, V, const MAX_ENTRIES: usize, const FLAGS: usize> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>
+pub fn aya_ebpf::btf_maps::hash_of_maps::HashOfMaps<K, V, MAX_ENTRIES, FLAGS>::from(t: T) -> T
 #[repr(C)] pub struct aya_ebpf::btf_maps::RingBuf<T, const MAX_ENTRIES: usize, const FLAGS: usize>
 impl<T, const MAX_ENTRIES: usize, const FLAGS: usize> aya_ebpf::btf_maps::ring_buf::RingBuf<T, MAX_ENTRIES, FLAGS>
 pub const fn aya_ebpf::btf_maps::ring_buf::RingBuf<T, MAX_ENTRIES, FLAGS>::new() -> Self
@@ -307,6 +429,7 @@ pub fn aya_ebpf::maps::array::Array<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::array::Array<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::array::Array<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::array::Array<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::array::Array<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::array::Array<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::array::Array<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::array::Array<T> where T: ?core::marker::Sized
@@ -315,6 +438,37 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::array::Array<T> where T:
 pub fn aya_ebpf::maps::array::Array<T>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::maps::array::Array<T>
 pub fn aya_ebpf::maps::array::Array<T>::from(t: T) -> T
+pub mod aya_ebpf::maps::array_of_maps
+#[repr(transparent)] pub struct aya_ebpf::maps::array_of_maps::ArrayOfMaps<T: aya_ebpf::maps::Map>
+impl<T: aya_ebpf::maps::Map> aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::get(&self, index: u32) -> core::option::Option<&T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::get_value(&self, outer_index: u32, inner_key: &<T as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<&<T as aya_ebpf::maps::private::Map>::Value>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::get_value_ptr_mut(&self, outer_index: u32, inner_key: &<T as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<*mut <T as aya_ebpf::maps::private::Map>::Value>
+pub const fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::pinned(max_entries: u32, flags: u32) -> Self
+pub const fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::with_max_entries(max_entries: u32, flags: u32) -> Self
+impl<T> !core::marker::Freeze for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+impl<T> core::marker::Send for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::marker::Send
+impl<T> core::marker::Sync for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::marker::Unpin
+impl<T> core::marker::UnsafeUnpin for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+impl<T> !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+impl<T> core::panic::unwind_safe::UnwindSafe for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where U: core::convert::From<T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where U: core::convert::Into<T>
+pub type aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::Error = core::convert::Infallible
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::from(t: T) -> T
 pub mod aya_ebpf::maps::bloom_filter
 #[repr(transparent)] pub struct aya_ebpf::maps::bloom_filter::BloomFilter<T>
 impl<T> aya_ebpf::maps::bloom_filter::BloomFilter<T>
@@ -337,6 +491,7 @@ pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::try_from(value: U) -> core:
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::bloom_filter::BloomFilter<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::bloom_filter::BloomFilter<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::bloom_filter::BloomFilter<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::bloom_filter::BloomFilter<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::bloom_filter::BloomFilter<T> where T: ?core::marker::Sized
@@ -370,6 +525,7 @@ pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::try_from(value: U) -> core::resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::HashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::HashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::HashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::HashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::HashMap<K, V> where T: ?core::marker::Sized
@@ -402,6 +558,7 @@ pub fn aya_ebpf::maps::hash_map::LruHashMap<K, V>::try_from(value: U) -> core::r
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::LruHashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::LruHashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::LruHashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::LruHashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::LruHashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::LruHashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::LruHashMap<K, V> where T: ?core::marker::Sized
@@ -434,6 +591,7 @@ pub fn aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::try_from(value: U) -> c
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where T: ?core::marker::Sized
@@ -466,6 +624,7 @@ pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::try_from(value: U) -> core
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where T: ?core::marker::Sized
@@ -474,6 +633,37 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::hash_map::PerCpuHashMap<K
 pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>
 pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::from(t: T) -> T
+pub mod aya_ebpf::maps::hash_of_maps
+#[repr(transparent)] pub struct aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V: aya_ebpf::maps::Map>
+impl<K, V: aya_ebpf::maps::Map> aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+pub unsafe fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::get(&self, key: &K) -> core::option::Option<&V>
+pub unsafe fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::get_value(&self, outer_key: &K, inner_key: &<V as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<&<V as aya_ebpf::maps::private::Map>::Value>
+pub unsafe fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::get_value_ptr_mut(&self, outer_key: &K, inner_key: &<V as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<*mut <V as aya_ebpf::maps::private::Map>::Value>
+pub const fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::pinned(max_entries: u32, flags: u32) -> Self
+pub const fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::with_max_entries(max_entries: u32, flags: u32) -> Self
+impl<K, V> !core::marker::Freeze for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+impl<K, V> core::marker::Send for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::marker::Send, V: core::marker::Send
+impl<K, V> core::marker::Sync for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::marker::Sync, V: core::marker::Sync
+impl<K, V> core::marker::Unpin for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::marker::Unpin, V: core::marker::Unpin
+impl<K, V> core::marker::UnsafeUnpin for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+impl<K, V> !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+impl<K, V> core::panic::unwind_safe::UnwindSafe for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where U: core::convert::From<T>
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where U: core::convert::Into<T>
+pub type aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::Error = core::convert::Infallible
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::from(t: T) -> T
 pub mod aya_ebpf::maps::lpm_trie
 #[repr(C, packed(1))] pub struct aya_ebpf::maps::lpm_trie::Key<K>
 pub aya_ebpf::maps::lpm_trie::Key::data: K
@@ -525,6 +715,7 @@ pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::try_from(value: U) -> core::resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where T: ?core::marker::Sized
@@ -556,6 +747,7 @@ pub fn aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::try_from(value: U) -> core
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where T: ?core::marker::Sized
@@ -675,6 +867,7 @@ pub fn aya_ebpf::maps::queue::Queue<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::queue::Queue<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::queue::Queue<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::queue::Queue<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::queue::Queue<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::queue::Queue<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::queue::Queue<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::queue::Queue<T> where T: ?core::marker::Sized
@@ -707,6 +900,7 @@ pub fn aya_ebpf::maps::ring_buf::RingBuf::try_from(value: U) -> core::result::Re
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::ring_buf::RingBuf where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::ring_buf::RingBuf::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::ring_buf::RingBuf::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::ring_buf::RingBuf where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::ring_buf::RingBuf where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::ring_buf::RingBuf::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::ring_buf::RingBuf where T: ?core::marker::Sized
@@ -807,6 +1001,7 @@ pub fn aya_ebpf::maps::sock_hash::SockHash<K>::try_from(value: U) -> core::resul
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::sock_hash::SockHash<K> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::sock_hash::SockHash<K>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::sock_hash::SockHash<K>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::sock_hash::SockHash<K> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::sock_hash::SockHash<K> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::sock_hash::SockHash<K>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::sock_hash::SockHash<K> where T: ?core::marker::Sized
@@ -839,6 +1034,7 @@ pub fn aya_ebpf::maps::sock_map::SockMap::try_from(value: U) -> core::result::Re
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::sock_map::SockMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::sock_map::SockMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::sock_map::SockMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::sock_map::SockMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::sock_map::SockMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::sock_map::SockMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::sock_map::SockMap where T: ?core::marker::Sized
@@ -870,6 +1066,7 @@ pub fn aya_ebpf::maps::stack::Stack<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::stack::Stack<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::stack::Stack<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::stack::Stack<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::stack::Stack<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::stack::Stack<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::stack::Stack<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::stack::Stack<T> where T: ?core::marker::Sized
@@ -899,6 +1096,7 @@ pub fn aya_ebpf::maps::stack_trace::StackTrace::try_from(value: U) -> core::resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::stack_trace::StackTrace where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::stack_trace::StackTrace::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::stack_trace::StackTrace::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::stack_trace::StackTrace where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::stack_trace::StackTrace where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::stack_trace::StackTrace::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::stack_trace::StackTrace where T: ?core::marker::Sized
@@ -928,6 +1126,7 @@ pub fn aya_ebpf::maps::CpuMap::try_from(value: U) -> core::result::Result<T, <T
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::CpuMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::CpuMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::CpuMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::CpuMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::CpuMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::CpuMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::CpuMap where T: ?core::marker::Sized
@@ -957,6 +1156,7 @@ pub fn aya_ebpf::maps::DevMap::try_from(value: U) -> core::result::Result<T, <T
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::DevMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::DevMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::DevMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::DevMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::DevMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::DevMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::DevMap where T: ?core::marker::Sized
@@ -986,6 +1186,7 @@ pub fn aya_ebpf::maps::DevMapHash::try_from(value: U) -> core::result::Result<T,
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::DevMapHash where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::DevMapHash::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::DevMapHash::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::DevMapHash where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::DevMapHash where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::DevMapHash::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::DevMapHash where T: ?core::marker::Sized
@@ -1015,6 +1216,7 @@ pub fn aya_ebpf::maps::XskMap::try_from(value: U) -> core::result::Result<T, <T
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::XskMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::XskMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::XskMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::XskMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::XskMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::XskMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::XskMap where T: ?core::marker::Sized
@@ -1046,6 +1248,7 @@ pub fn aya_ebpf::maps::array::Array<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::array::Array<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::array::Array<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::array::Array<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::array::Array<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::array::Array<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::array::Array<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::array::Array<T> where T: ?core::marker::Sized
@@ -1054,6 +1257,36 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::array::Array<T> where T:
 pub fn aya_ebpf::maps::array::Array<T>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::maps::array::Array<T>
 pub fn aya_ebpf::maps::array::Array<T>::from(t: T) -> T
+#[repr(transparent)] pub struct aya_ebpf::maps::ArrayOfMaps<T: aya_ebpf::maps::Map>
+impl<T: aya_ebpf::maps::Map> aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::get(&self, index: u32) -> core::option::Option<&T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::get_value(&self, outer_index: u32, inner_key: &<T as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<&<T as aya_ebpf::maps::private::Map>::Value>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::get_value_ptr_mut(&self, outer_index: u32, inner_key: &<T as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<*mut <T as aya_ebpf::maps::private::Map>::Value>
+pub const fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::pinned(max_entries: u32, flags: u32) -> Self
+pub const fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::with_max_entries(max_entries: u32, flags: u32) -> Self
+impl<T> !core::marker::Freeze for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+impl<T> core::marker::Send for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::marker::Send
+impl<T> core::marker::Sync for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::marker::Unpin
+impl<T> core::marker::UnsafeUnpin for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+impl<T> !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+impl<T> core::panic::unwind_safe::UnwindSafe for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where U: core::convert::From<T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where U: core::convert::Into<T>
+pub type aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::Error = core::convert::Infallible
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>
+pub fn aya_ebpf::maps::array_of_maps::ArrayOfMaps<T>::from(t: T) -> T
 #[repr(transparent)] pub struct aya_ebpf::maps::BloomFilter<T>
 impl<T> aya_ebpf::maps::bloom_filter::BloomFilter<T>
 pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::contains(&self, value: impl core::borrow::Borrow<T>) -> core::result::Result<(), i64>
@@ -1075,6 +1308,7 @@ pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::try_from(value: U) -> core:
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::bloom_filter::BloomFilter<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::bloom_filter::BloomFilter<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::bloom_filter::BloomFilter<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::bloom_filter::BloomFilter<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::bloom_filter::BloomFilter<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::bloom_filter::BloomFilter<T> where T: ?core::marker::Sized
@@ -1103,6 +1337,7 @@ pub fn aya_ebpf::maps::CpuMap::try_from(value: U) -> core::result::Result<T, <T
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::CpuMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::CpuMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::CpuMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::CpuMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::CpuMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::CpuMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::CpuMap where T: ?core::marker::Sized
@@ -1132,6 +1367,7 @@ pub fn aya_ebpf::maps::DevMap::try_from(value: U) -> core::result::Result<T, <T
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::DevMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::DevMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::DevMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::DevMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::DevMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::DevMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::DevMap where T: ?core::marker::Sized
@@ -1161,6 +1397,7 @@ pub fn aya_ebpf::maps::DevMapHash::try_from(value: U) -> core::result::Result<T,
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::DevMapHash where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::DevMapHash::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::DevMapHash::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::DevMapHash where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::DevMapHash where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::DevMapHash::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::DevMapHash where T: ?core::marker::Sized
@@ -1193,6 +1430,7 @@ pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::try_from(value: U) -> core::resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::HashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::HashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::HashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::HashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::HashMap<K, V> where T: ?core::marker::Sized
@@ -1201,6 +1439,36 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::hash_map::HashMap<K, V> w
 pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::maps::hash_map::HashMap<K, V>
 pub fn aya_ebpf::maps::hash_map::HashMap<K, V>::from(t: T) -> T
+#[repr(transparent)] pub struct aya_ebpf::maps::HashOfMaps<K, V: aya_ebpf::maps::Map>
+impl<K, V: aya_ebpf::maps::Map> aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+pub unsafe fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::get(&self, key: &K) -> core::option::Option<&V>
+pub unsafe fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::get_value(&self, outer_key: &K, inner_key: &<V as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<&<V as aya_ebpf::maps::private::Map>::Value>
+pub unsafe fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::get_value_ptr_mut(&self, outer_key: &K, inner_key: &<V as aya_ebpf::maps::private::Map>::Key) -> core::option::Option<*mut <V as aya_ebpf::maps::private::Map>::Value>
+pub const fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::pinned(max_entries: u32, flags: u32) -> Self
+pub const fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::with_max_entries(max_entries: u32, flags: u32) -> Self
+impl<K, V> !core::marker::Freeze for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+impl<K, V> core::marker::Send for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::marker::Send, V: core::marker::Send
+impl<K, V> core::marker::Sync for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::marker::Sync, V: core::marker::Sync
+impl<K, V> core::marker::Unpin for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::marker::Unpin, V: core::marker::Unpin
+impl<K, V> core::marker::UnsafeUnpin for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+impl<K, V> !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+impl<K, V> core::panic::unwind_safe::UnwindSafe for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where K: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where U: core::convert::From<T>
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where U: core::convert::Into<T>
+pub type aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::Error = core::convert::Infallible
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V> where T: ?core::marker::Sized
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>
+pub fn aya_ebpf::maps::hash_of_maps::HashOfMaps<K, V>::from(t: T) -> T
 #[repr(transparent)] pub struct aya_ebpf::maps::LpmTrie<K, V>
 impl<K, V> aya_ebpf::maps::lpm_trie::LpmTrie<K, V>
 pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::get(&self, key: impl core::borrow::Borrow<aya_ebpf::maps::lpm_trie::Key<K>>) -> core::option::Option<&V>
@@ -1223,6 +1491,7 @@ pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::try_from(value: U) -> core::resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::lpm_trie::LpmTrie<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::lpm_trie::LpmTrie<K, V> where T: ?core::marker::Sized
@@ -1255,6 +1524,7 @@ pub fn aya_ebpf::maps::hash_map::LruHashMap<K, V>::try_from(value: U) -> core::r
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::LruHashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::LruHashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::LruHashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::LruHashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::LruHashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::LruHashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::LruHashMap<K, V> where T: ?core::marker::Sized
@@ -1287,6 +1557,7 @@ pub fn aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::try_from(value: U) -> c
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::LruPerCpuHashMap<K, V> where T: ?core::marker::Sized
@@ -1317,6 +1588,7 @@ pub fn aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::try_from(value: U) -> core
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::per_cpu_array::PerCpuArray<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::per_cpu_array::PerCpuArray<T> where T: ?core::marker::Sized
@@ -1349,6 +1621,7 @@ pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::try_from(value: U) -> core
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::hash_map::PerCpuHashMap<K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::hash_map::PerCpuHashMap<K, V> where T: ?core::marker::Sized
@@ -1465,6 +1738,7 @@ pub fn aya_ebpf::maps::queue::Queue<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::queue::Queue<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::queue::Queue<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::queue::Queue<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::queue::Queue<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::queue::Queue<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::queue::Queue<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::queue::Queue<T> where T: ?core::marker::Sized
@@ -1496,6 +1770,7 @@ pub fn aya_ebpf::maps::ring_buf::RingBuf::try_from(value: U) -> core::result::Re
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::ring_buf::RingBuf where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::ring_buf::RingBuf::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::ring_buf::RingBuf::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::ring_buf::RingBuf where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::ring_buf::RingBuf where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::ring_buf::RingBuf::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::ring_buf::RingBuf where T: ?core::marker::Sized
@@ -1527,6 +1802,7 @@ pub fn aya_ebpf::maps::sock_hash::SockHash<K>::try_from(value: U) -> core::resul
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::sock_hash::SockHash<K> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::sock_hash::SockHash<K>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::sock_hash::SockHash<K>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::sock_hash::SockHash<K> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::sock_hash::SockHash<K> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::sock_hash::SockHash<K>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::sock_hash::SockHash<K> where T: ?core::marker::Sized
@@ -1558,6 +1834,7 @@ pub fn aya_ebpf::maps::sock_map::SockMap::try_from(value: U) -> core::result::Re
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::sock_map::SockMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::sock_map::SockMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::sock_map::SockMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::sock_map::SockMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::sock_map::SockMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::sock_map::SockMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::sock_map::SockMap where T: ?core::marker::Sized
@@ -1588,6 +1865,7 @@ pub fn aya_ebpf::maps::stack::Stack<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::stack::Stack<T> where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::stack::Stack<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::stack::Stack<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::stack::Stack<T> where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::stack::Stack<T> where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::stack::Stack<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::stack::Stack<T> where T: ?core::marker::Sized
@@ -1616,6 +1894,7 @@ pub fn aya_ebpf::maps::stack_trace::StackTrace::try_from(value: U) -> core::resu
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::stack_trace::StackTrace where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::stack_trace::StackTrace::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::stack_trace::StackTrace::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::stack_trace::StackTrace where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::stack_trace::StackTrace where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::stack_trace::StackTrace::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::stack_trace::StackTrace where T: ?core::marker::Sized
@@ -1645,6 +1924,7 @@ pub fn aya_ebpf::maps::XskMap::try_from(value: U) -> core::result::Result<T, <T
 impl<T, U> core::convert::TryInto<U> for aya_ebpf::maps::XskMap where U: core::convert::TryFrom<T>
 pub type aya_ebpf::maps::XskMap::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya_ebpf::maps::XskMap::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya_ebpf::maps::Map for aya_ebpf::maps::XskMap where T: aya_ebpf::maps::private::Map
 impl<T> core::any::Any for aya_ebpf::maps::XskMap where T: 'static + ?core::marker::Sized
 pub fn aya_ebpf::maps::XskMap::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya_ebpf::maps::XskMap where T: ?core::marker::Sized
@@ -1653,6 +1933,8 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::maps::XskMap where T: ?core::ma
 pub fn aya_ebpf::maps::XskMap::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::maps::XskMap
 pub fn aya_ebpf::maps::XskMap::from(t: T) -> T
+pub trait aya_ebpf::maps::Map: aya_ebpf::maps::private::Map
+impl<T: aya_ebpf::maps::private::Map> aya_ebpf::maps::Map for T
 pub mod aya_ebpf::programs
 pub mod aya_ebpf::programs::device
 pub struct aya_ebpf::programs::device::DeviceContext
diff --git a/xtask/public-api/aya-obj.txt b/xtask/public-api/aya-obj.txt
index 207acf59f..58fc22354 100644
--- a/xtask/public-api/aya-obj.txt
+++ b/xtask/public-api/aya-obj.txt
@@ -4,6 +4,8 @@ pub enum aya_obj::btf::BtfError
 pub aya_obj::btf::BtfError::FileError
 pub aya_obj::btf::BtfError::FileError::error: std::io::error::Error
 pub aya_obj::btf::BtfError::FileError::path: std::path::PathBuf
+pub aya_obj::btf::BtfError::InnerMapCannotBePinned
+pub aya_obj::btf::BtfError::InnerMapCannotBePinned::name: alloc::string::String
 pub aya_obj::btf::BtfError::InvalidDatasec
 pub aya_obj::btf::BtfError::InvalidHeader
 pub aya_obj::btf::BtfError::InvalidInfo
@@ -23,11 +25,15 @@ pub aya_obj::btf::BtfError::InvalidSymbolName
 pub aya_obj::btf::BtfError::InvalidTypeInfo
 pub aya_obj::btf::BtfError::InvalidTypeKind
 pub aya_obj::btf::BtfError::InvalidTypeKind::kind: u32
+pub aya_obj::btf::BtfError::InvalidValuesSpec
+pub aya_obj::btf::BtfError::InvalidValuesSpec::name: alloc::string::String
 pub aya_obj::btf::BtfError::LoadError
 pub aya_obj::btf::BtfError::LoadError::io_error: std::io::error::Error
 pub aya_obj::btf::BtfError::LoadError::verifier_log: aya_obj::VerifierLog
 pub aya_obj::btf::BtfError::MaximumTypeDepthReached
 pub aya_obj::btf::BtfError::MaximumTypeDepthReached::type_id: u32
+pub aya_obj::btf::BtfError::MultiLevelMapInMapNotSupported
+pub aya_obj::btf::BtfError::MultiLevelMapInMapNotSupported::name: alloc::string::String
 pub aya_obj::btf::BtfError::SymbolOffsetNotFound
 pub aya_obj::btf::BtfError::SymbolOffsetNotFound::symbol_name: alloc::string::String
 pub aya_obj::btf::BtfError::UnexpectedBtfType
@@ -8383,10 +8389,12 @@ pub aya_obj::maps::Map::Legacy(aya_obj::maps::LegacyMap)
 impl aya_obj::maps::Map
 pub fn aya_obj::maps::Map::data(&self) -> &[u8]
 pub fn aya_obj::maps::Map::data_mut(&mut self) -> &mut alloc::vec::Vec<u8>
+pub fn aya_obj::maps::Map::inner(&self) -> core::option::Option<Self>
 pub const fn aya_obj::maps::Map::key_size(&self) -> u32
 pub const fn aya_obj::maps::Map::map_flags(&self) -> u32
 pub const fn aya_obj::maps::Map::map_type(&self) -> u32
 pub const fn aya_obj::maps::Map::max_entries(&self) -> u32
+pub const fn aya_obj::maps::Map::new_legacy(map_type: u32, key_size: u32, value_size: u32, max_entries: u32, flags: u32) -> Self
 pub const fn aya_obj::maps::Map::pinning(&self) -> aya_obj::maps::PinningType
 pub const fn aya_obj::maps::Map::section_index(&self) -> usize
 pub const fn aya_obj::maps::Map::section_kind(&self) -> aya_obj::EbpfSectionKind
@@ -8587,6 +8595,7 @@ pub fn aya_obj::maps::BtfMapDef::from(t: T) -> T
 pub struct aya_obj::maps::LegacyMap
 pub aya_obj::maps::LegacyMap::data: alloc::vec::Vec<u8>
 pub aya_obj::maps::LegacyMap::def: aya_obj::maps::bpf_map_def
+pub aya_obj::maps::LegacyMap::inner_def: core::option::Option<aya_obj::maps::bpf_map_def>
 pub aya_obj::maps::LegacyMap::section_index: usize
 pub aya_obj::maps::LegacyMap::section_kind: aya_obj::EbpfSectionKind
 pub aya_obj::maps::LegacyMap::symbol_index: core::option::Option<usize>
@@ -8680,6 +8689,7 @@ pub aya_obj::obj::EbpfSectionKind::BtfMaps
 pub aya_obj::obj::EbpfSectionKind::Data
 pub aya_obj::obj::EbpfSectionKind::License
 pub aya_obj::obj::EbpfSectionKind::Maps
+pub aya_obj::obj::EbpfSectionKind::MapsInner
 pub aya_obj::obj::EbpfSectionKind::Program
 pub aya_obj::obj::EbpfSectionKind::Rodata
 pub aya_obj::obj::EbpfSectionKind::Text
@@ -8736,6 +8746,9 @@ pub aya_obj::obj::ParseError::InvalidLicense
 pub aya_obj::obj::ParseError::InvalidLicense::data: alloc::vec::Vec<u8>
 pub aya_obj::obj::ParseError::InvalidMapDefinition
 pub aya_obj::obj::ParseError::InvalidMapDefinition::name: alloc::string::String
+pub aya_obj::obj::ParseError::InvalidMapsInnerSection
+pub aya_obj::obj::ParseError::InvalidMapsInnerSection::msg: &'static str
+pub aya_obj::obj::ParseError::InvalidMapsInnerSection::offset: usize
 pub aya_obj::obj::ParseError::InvalidProgramCode
 pub aya_obj::obj::ParseError::InvalidProgramSection
 pub aya_obj::obj::ParseError::InvalidProgramSection::section: alloc::string::String
@@ -8994,6 +9007,7 @@ impl aya_obj::Object
 pub fn aya_obj::Object::fixup_and_sanitize_btf(&mut self, features: &aya_obj::btf::BtfFeatures) -> core::result::Result<core::option::Option<&aya_obj::btf::Btf>, aya_obj::btf::BtfError>
 impl aya_obj::Object
 pub fn aya_obj::Object::has_btf_relocations(&self) -> bool
+pub fn aya_obj::Object::inner_map_binding(&self, outer: &str) -> core::option::Option<&str>
 pub fn aya_obj::Object::parse(data: &[u8]) -> core::result::Result<Self, aya_obj::ParseError>
 pub fn aya_obj::Object::patch_map_data(&mut self, globals: std::collections::hash::map::HashMap<&str, (&[u8], bool)>) -> core::result::Result<(), aya_obj::ParseError>
 pub fn aya_obj::Object::sanitize_functions(&mut self, features: &aya_obj::Features)
@@ -9512,6 +9526,7 @@ pub aya_obj::EbpfSectionKind::BtfMaps
 pub aya_obj::EbpfSectionKind::Data
 pub aya_obj::EbpfSectionKind::License
 pub aya_obj::EbpfSectionKind::Maps
+pub aya_obj::EbpfSectionKind::MapsInner
 pub aya_obj::EbpfSectionKind::Program
 pub aya_obj::EbpfSectionKind::Rodata
 pub aya_obj::EbpfSectionKind::Text
@@ -9561,10 +9576,12 @@ pub aya_obj::Map::Legacy(aya_obj::maps::LegacyMap)
 impl aya_obj::maps::Map
 pub fn aya_obj::maps::Map::data(&self) -> &[u8]
 pub fn aya_obj::maps::Map::data_mut(&mut self) -> &mut alloc::vec::Vec<u8>
+pub fn aya_obj::maps::Map::inner(&self) -> core::option::Option<Self>
 pub const fn aya_obj::maps::Map::key_size(&self) -> u32
 pub const fn aya_obj::maps::Map::map_flags(&self) -> u32
 pub const fn aya_obj::maps::Map::map_type(&self) -> u32
 pub const fn aya_obj::maps::Map::max_entries(&self) -> u32
+pub const fn aya_obj::maps::Map::new_legacy(map_type: u32, key_size: u32, value_size: u32, max_entries: u32, flags: u32) -> Self
 pub const fn aya_obj::maps::Map::pinning(&self) -> aya_obj::maps::PinningType
 pub const fn aya_obj::maps::Map::section_index(&self) -> usize
 pub const fn aya_obj::maps::Map::section_kind(&self) -> aya_obj::EbpfSectionKind
@@ -9618,6 +9635,9 @@ pub aya_obj::ParseError::InvalidLicense
 pub aya_obj::ParseError::InvalidLicense::data: alloc::vec::Vec<u8>
 pub aya_obj::ParseError::InvalidMapDefinition
 pub aya_obj::ParseError::InvalidMapDefinition::name: alloc::string::String
+pub aya_obj::ParseError::InvalidMapsInnerSection
+pub aya_obj::ParseError::InvalidMapsInnerSection::msg: &'static str
+pub aya_obj::ParseError::InvalidMapsInnerSection::offset: usize
 pub aya_obj::ParseError::InvalidProgramCode
 pub aya_obj::ParseError::InvalidProgramSection
 pub aya_obj::ParseError::InvalidProgramSection::section: alloc::string::String
@@ -9876,6 +9896,7 @@ impl aya_obj::Object
 pub fn aya_obj::Object::fixup_and_sanitize_btf(&mut self, features: &aya_obj::btf::BtfFeatures) -> core::result::Result<core::option::Option<&aya_obj::btf::Btf>, aya_obj::btf::BtfError>
 impl aya_obj::Object
 pub fn aya_obj::Object::has_btf_relocations(&self) -> bool
+pub fn aya_obj::Object::inner_map_binding(&self, outer: &str) -> core::option::Option<&str>
 pub fn aya_obj::Object::parse(data: &[u8]) -> core::result::Result<Self, aya_obj::ParseError>
 pub fn aya_obj::Object::patch_map_data(&mut self, globals: std::collections::hash::map::HashMap<&str, (&[u8], bool)>) -> core::result::Result<(), aya_obj::ParseError>
 pub fn aya_obj::Object::sanitize_functions(&mut self, features: &aya_obj::Features)
diff --git a/xtask/public-api/aya.txt b/xtask/public-api/aya.txt
index fd6a16eeb..739d8d5a2 100644
--- a/xtask/public-api/aya.txt
+++ b/xtask/public-api/aya.txt
@@ -15,6 +15,8 @@ impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::array:
 pub fn aya::maps::array::Array<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::array::Array<T, V>
 pub fn aya::maps::array::Array<T, V>::set(&mut self, index: u32, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::array::Array<aya::maps::MapData, V>
+pub fn aya::maps::array::Array<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::array::Array<&'a aya::maps::MapData, V>
 pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::array::Array<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -42,6 +44,10 @@ pub fn aya::maps::array::Array<T, V>::try_from(value: U) -> core::result::Result
 impl<T, U> core::convert::TryInto<U> for aya::maps::array::Array<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::array::Array<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::array::Array<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::array::Array<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::array::Array<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::array::Array<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::array::Array<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::array::Array<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::array::Array<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::array::Array<T, V> where T: ?core::marker::Sized
@@ -59,6 +65,8 @@ impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::PerCpu
 pub fn aya::maps::PerCpuArray<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::PerCpuArray<T, V>
 pub fn aya::maps::PerCpuArray<T, V>::set(&mut self, index: u32, values: aya::maps::PerCpuValues<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::PerCpuArray<aya::maps::MapData, V>
+pub fn aya::maps::PerCpuArray<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::PerCpuArray<&'a aya::maps::MapData, V>
 pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -86,6 +94,10 @@ pub fn aya::maps::PerCpuArray<T, V>::try_from(value: U) -> core::result::Result<
 impl<T, U> core::convert::TryInto<U> for aya::maps::PerCpuArray<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::PerCpuArray<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::PerCpuArray<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::PerCpuArray<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::PerCpuArray<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::PerCpuArray<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::PerCpuArray<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::PerCpuArray<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::PerCpuArray<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::PerCpuArray<T, V> where T: ?core::marker::Sized
@@ -142,6 +154,8 @@ impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::bloom_
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::bloom_filter::BloomFilter<T, V>
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::insert(&mut self, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::bloom_filter::BloomFilter<aya::maps::MapData, V>
+pub fn aya::maps::bloom_filter::BloomFilter<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>
 pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -168,6 +182,10 @@ pub fn aya::maps::bloom_filter::BloomFilter<T, V>::try_from(value: U) -> core::r
 impl<T, U> core::convert::TryInto<U> for aya::maps::bloom_filter::BloomFilter<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::bloom_filter::BloomFilter<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::bloom_filter::BloomFilter<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::bloom_filter::BloomFilter<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::bloom_filter::BloomFilter<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::bloom_filter::BloomFilter<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::bloom_filter::BloomFilter<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::bloom_filter::BloomFilter<T, V> where T: ?core::marker::Sized
@@ -178,6 +196,8 @@ impl<T> core::convert::From<T> for aya::maps::bloom_filter::BloomFilter<T, V>
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::from(t: T) -> T
 pub mod aya::maps::hash_map
 pub struct aya::maps::hash_map::HashMap<T, K, V>
+impl<K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap<aya::maps::MapData, K, V>
+pub fn aya::maps::hash_map::HashMap<aya::maps::MapData, K, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap<T, K, V>
 pub fn aya::maps::hash_map::HashMap<T, K, V>::get(&self, key: &K, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::hash_map::HashMap<T, K, V>::iter(&self) -> aya::maps::MapIter<'_, K, V, Self>
@@ -220,6 +240,10 @@ pub fn aya::maps::hash_map::HashMap<T, K, V>::try_from(value: U) -> core::result
 impl<T, U> core::convert::TryInto<U> for aya::maps::hash_map::HashMap<T, K, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::hash_map::HashMap<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::hash_map::HashMap<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::hash_map::HashMap<T, K, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::hash_map::HashMap<T, K, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::hash_map::HashMap<T, K, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::hash_map::HashMap<T, K, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::hash_map::HashMap<T, K, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::hash_map::HashMap<T, K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::hash_map::HashMap<T, K, V> where T: ?core::marker::Sized
@@ -229,6 +253,8 @@ pub fn aya::maps::hash_map::HashMap<T, K, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::hash_map::HashMap<T, K, V>
 pub fn aya::maps::hash_map::HashMap<T, K, V>::from(t: T) -> T
 pub struct aya::maps::hash_map::PerCpuHashMap<T, K: aya::Pod, V: aya::Pod>
+impl<K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap<aya::maps::MapData, K, V>
+pub fn aya::maps::hash_map::PerCpuHashMap<aya::maps::MapData, K, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap<T, K, V>
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::get(&self, key: &K, flags: u64) -> core::result::Result<aya::maps::PerCpuValues<V>, aya::maps::MapError>
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::iter(&self) -> aya::maps::MapIter<'_, K, aya::maps::PerCpuValues<V>, Self>
@@ -269,6 +295,10 @@ pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::try_from(value: U) -> core::
 impl<T, U> core::convert::TryInto<U> for aya::maps::hash_map::PerCpuHashMap<T, K, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::hash_map::PerCpuHashMap<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: ?core::marker::Sized
@@ -320,6 +350,8 @@ pub unsafe fn aya::maps::lpm_trie::Key<K>::clone_to_uninit(&self, dest: *mut u8)
 impl<T> core::convert::From<T> for aya::maps::lpm_trie::Key<K>
 pub fn aya::maps::lpm_trie::Key<K>::from(t: T) -> T
 pub struct aya::maps::lpm_trie::LpmTrie<T, K, V>
+impl<K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>
+pub fn aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie<T, K, V>
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::get(&self, key: &aya::maps::lpm_trie::Key<K>, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::iter(&self) -> aya::maps::MapIter<'_, aya::maps::lpm_trie::Key<K>, V, Self>
@@ -362,6 +394,10 @@ pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::try_from(value: U) -> core::result
 impl<T, U> core::convert::TryInto<U> for aya::maps::lpm_trie::LpmTrie<T, K, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::lpm_trie::LpmTrie<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: ?core::marker::Sized
@@ -370,6 +406,96 @@ impl<T> core::borrow::BorrowMut<T> for aya::maps::lpm_trie::LpmTrie<T, K, V> whe
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::lpm_trie::LpmTrie<T, K, V>
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::from(t: T) -> T
+pub mod aya::maps::of_maps
+pub struct aya::maps::of_maps::ArrayOfMaps<T, V>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::maps::FromMapData> aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::get(&self, index: &u32, flags: u64) -> core::result::Result<V, aya::maps::MapError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V> aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::is_empty(&self) -> bool
+pub fn aya::maps::ArrayOfMaps<T, V>::len(&self) -> u32
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::maps::InnerMap> aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::set(&mut self, index: u32, value: &V, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V> aya::maps::ArrayOfMaps<aya::maps::MapData, V>
+pub fn aya::maps::ArrayOfMaps<aya::maps::MapData, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
+impl<'a, V> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, V> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T: core::fmt::Debug, V> core::fmt::Debug for aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V> core::convert::TryFrom<aya::maps::Map> for aya::maps::ArrayOfMaps<aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T, V> core::marker::Freeze for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Freeze
+impl<T, V> core::marker::Send for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Send, V: core::marker::Send
+impl<T, V> core::marker::Sync for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Sync, V: core::marker::Sync
+impl<T, V> core::marker::Unpin for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Unpin, V: core::marker::Unpin
+impl<T, V> core::marker::UnsafeUnpin for aya::maps::ArrayOfMaps<T, V> where T: core::marker::UnsafeUnpin
+impl<T, V> core::panic::unwind_safe::RefUnwindSafe for aya::maps::ArrayOfMaps<T, V> where T: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, V> core::panic::unwind_safe::UnwindSafe for aya::maps::ArrayOfMaps<T, V> where T: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya::maps::ArrayOfMaps<T, V> where U: core::convert::From<T>
+pub fn aya::maps::ArrayOfMaps<T, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya::maps::ArrayOfMaps<T, V> where U: core::convert::Into<T>
+pub type aya::maps::ArrayOfMaps<T, V>::Error = core::convert::Infallible
+pub fn aya::maps::ArrayOfMaps<T, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya::maps::ArrayOfMaps<T, V> where U: core::convert::TryFrom<T>
+pub type aya::maps::ArrayOfMaps<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya::maps::ArrayOfMaps<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya::maps::ArrayOfMaps<T, V> where T: 'static + ?core::marker::Sized
+pub fn aya::maps::ArrayOfMaps<T, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya::maps::ArrayOfMaps<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::ArrayOfMaps<T, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya::maps::ArrayOfMaps<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::ArrayOfMaps<T, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::from(t: T) -> T
+pub struct aya::maps::of_maps::HashOfMaps<T, K, V>
+impl<K: aya::Pod, V> aya::maps::HashOfMaps<aya::maps::MapData, K, V>
+pub fn aya::maps::HashOfMaps<aya::maps::MapData, K, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::maps::FromMapData> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::get(&self, key: &K, flags: u64) -> core::result::Result<V, aya::maps::MapError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::keys(&self) -> aya::maps::MapKeys<'_, K>
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, K: aya::Pod, V: aya::maps::InnerMap> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::insert(&mut self, key: impl core::borrow::Borrow<K>, value: &V, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, K: aya::Pod, V> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError>
+impl<'a, K: aya::Pod, V> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, K: aya::Pod, V> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<K: aya::Pod, V> core::convert::TryFrom<aya::maps::Map> for aya::maps::HashOfMaps<aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<aya::maps::MapData, K, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T: core::fmt::Debug, K, V> core::fmt::Debug for aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<T, K, V> core::marker::Freeze for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Freeze
+impl<T, K, V> core::marker::Send for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Send, K: core::marker::Send, V: core::marker::Send
+impl<T, K, V> core::marker::Sync for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Sync, K: core::marker::Sync, V: core::marker::Sync
+impl<T, K, V> core::marker::Unpin for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Unpin, K: core::marker::Unpin, V: core::marker::Unpin
+impl<T, K, V> core::marker::UnsafeUnpin for aya::maps::HashOfMaps<T, K, V> where T: core::marker::UnsafeUnpin
+impl<T, K, V> core::panic::unwind_safe::RefUnwindSafe for aya::maps::HashOfMaps<T, K, V> where T: core::panic::unwind_safe::RefUnwindSafe, K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, K, V> core::panic::unwind_safe::UnwindSafe for aya::maps::HashOfMaps<T, K, V> where T: core::panic::unwind_safe::UnwindSafe, K: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya::maps::HashOfMaps<T, K, V> where U: core::convert::From<T>
+pub fn aya::maps::HashOfMaps<T, K, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya::maps::HashOfMaps<T, K, V> where U: core::convert::Into<T>
+pub type aya::maps::HashOfMaps<T, K, V>::Error = core::convert::Infallible
+pub fn aya::maps::HashOfMaps<T, K, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya::maps::HashOfMaps<T, K, V> where U: core::convert::TryFrom<T>
+pub type aya::maps::HashOfMaps<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya::maps::HashOfMaps<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya::maps::HashOfMaps<T, K, V> where T: 'static + ?core::marker::Sized
+pub fn aya::maps::HashOfMaps<T, K, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya::maps::HashOfMaps<T, K, V> where T: ?core::marker::Sized
+pub fn aya::maps::HashOfMaps<T, K, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya::maps::HashOfMaps<T, K, V> where T: ?core::marker::Sized
+pub fn aya::maps::HashOfMaps<T, K, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::from(t: T) -> T
 pub mod aya::maps::perf
 pub enum aya::maps::perf::PerfBufferError
 pub aya::maps::perf::PerfBufferError::IOError(std::io::error::Error)
@@ -480,6 +606,10 @@ pub fn aya::maps::perf::PerfEventArray<T>::try_from(value: U) -> core::result::R
 impl<T, U> core::convert::TryInto<U> for aya::maps::perf::PerfEventArray<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::perf::PerfEventArray<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::perf::PerfEventArray<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::perf::PerfEventArray<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::perf::PerfEventArray<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::perf::PerfEventArray<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::perf::PerfEventArray<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::perf::PerfEventArray<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::perf::PerfEventArray<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::perf::PerfEventArray<T> where T: ?core::marker::Sized
@@ -528,6 +658,8 @@ pub fn aya::maps::queue::Queue<T, V>::pin<P: core::convert::AsRef<std::path::Pat
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::queue::Queue<T, V>
 pub fn aya::maps::queue::Queue<T, V>::pop(&mut self, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::queue::Queue<T, V>::push(&mut self, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::queue::Queue<aya::maps::MapData, V>
+pub fn aya::maps::queue::Queue<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::queue::Queue<&'a aya::maps::MapData, V>
 pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::queue::Queue<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -552,6 +684,10 @@ pub fn aya::maps::queue::Queue<T, V>::try_from(value: U) -> core::result::Result
 impl<T, U> core::convert::TryInto<U> for aya::maps::queue::Queue<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::queue::Queue<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::queue::Queue<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::queue::Queue<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::queue::Queue<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::queue::Queue<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::queue::Queue<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::queue::Queue<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::queue::Queue<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::queue::Queue<T, V> where T: ?core::marker::Sized
@@ -592,6 +728,10 @@ pub fn aya::maps::ring_buf::RingBuf<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya::maps::ring_buf::RingBuf<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::ring_buf::RingBuf<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::ring_buf::RingBuf<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::ring_buf::RingBuf<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::ring_buf::RingBuf<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::ring_buf::RingBuf<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::ring_buf::RingBuf<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::ring_buf::RingBuf<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::ring_buf::RingBuf<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::ring_buf::RingBuf<T> where T: ?core::marker::Sized
@@ -668,6 +808,10 @@ pub fn aya::maps::sk_storage::SkStorage<T, V>::try_from(value: U) -> core::resul
 impl<T, U> core::convert::TryInto<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::sk_storage::SkStorage<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::sk_storage::SkStorage<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::sk_storage::SkStorage<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::sk_storage::SkStorage<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::sk_storage::SkStorage<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::sk_storage::SkStorage<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::sk_storage::SkStorage<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::sk_storage::SkStorage<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::sk_storage::SkStorage<T, V> where T: ?core::marker::Sized
@@ -719,6 +863,10 @@ pub fn aya::maps::SockHash<T, K>::try_from(value: U) -> core::result::Result<T,
 impl<T, U> core::convert::TryInto<U> for aya::maps::SockHash<T, K> where U: core::convert::TryFrom<T>
 pub type aya::maps::SockHash<T, K>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::SockHash<T, K>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::SockHash<T, K> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::SockHash<T, K>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::SockHash<T, K> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::SockHash<T, K>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::SockHash<T, K> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::SockHash<T, K>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::SockHash<T, K> where T: ?core::marker::Sized
@@ -760,6 +908,10 @@ pub fn aya::maps::SockMap<T>::try_from(value: U) -> core::result::Result<T, <T a
 impl<T, U> core::convert::TryInto<U> for aya::maps::SockMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::SockMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::SockMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::SockMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::SockMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::SockMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::SockMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::SockMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::SockMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::SockMap<T> where T: ?core::marker::Sized
@@ -805,6 +957,8 @@ pub fn aya::maps::stack::Stack<T, V>::pin<P: core::convert::AsRef<std::path::Pat
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::stack::Stack<T, V>
 pub fn aya::maps::stack::Stack<T, V>::pop(&mut self, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::stack::Stack<T, V>::push(&mut self, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::stack::Stack<aya::maps::MapData, V>
+pub fn aya::maps::stack::Stack<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack::Stack<&'a aya::maps::MapData, V>
 pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::stack::Stack<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -829,6 +983,10 @@ pub fn aya::maps::stack::Stack<T, V>::try_from(value: U) -> core::result::Result
 impl<T, U> core::convert::TryInto<U> for aya::maps::stack::Stack<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::stack::Stack<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::stack::Stack<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::stack::Stack<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::stack::Stack<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::stack::Stack<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::stack::Stack<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::stack::Stack<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::stack::Stack<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::stack::Stack<T, V> where T: ?core::marker::Sized
@@ -935,6 +1093,10 @@ pub fn aya::maps::stack_trace::StackTraceMap<T>::try_from(value: U) -> core::res
 impl<T, U> core::convert::TryInto<U> for aya::maps::stack_trace::StackTraceMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::stack_trace::StackTraceMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::stack_trace::StackTraceMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::stack_trace::StackTraceMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::stack_trace::StackTraceMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::stack_trace::StackTraceMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::stack_trace::StackTraceMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::stack_trace::StackTraceMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::stack_trace::StackTraceMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::stack_trace::StackTraceMap<T> where T: ?core::marker::Sized
@@ -1013,6 +1175,10 @@ pub fn aya::maps::CpuMap<T>::try_from(value: U) -> core::result::Result<T, <T as
 impl<T, U> core::convert::TryInto<U> for aya::maps::CpuMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::CpuMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::CpuMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::CpuMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::CpuMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::CpuMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::CpuMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::CpuMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::CpuMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::CpuMap<T> where T: ?core::marker::Sized
@@ -1054,6 +1220,10 @@ pub fn aya::maps::DevMap<T>::try_from(value: U) -> core::result::Result<T, <T as
 impl<T, U> core::convert::TryInto<U> for aya::maps::DevMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::DevMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::DevMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::DevMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::DevMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::DevMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::DevMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::DevMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::DevMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::DevMap<T> where T: ?core::marker::Sized
@@ -1100,6 +1270,10 @@ pub fn aya::maps::DevMapHash<T>::try_from(value: U) -> core::result::Result<T, <
 impl<T, U> core::convert::TryInto<U> for aya::maps::DevMapHash<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::DevMapHash<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::DevMapHash<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::DevMapHash<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::DevMapHash<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::DevMapHash<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::DevMapHash<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::DevMapHash<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::DevMapHash<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::DevMapHash<T> where T: ?core::marker::Sized
@@ -1140,6 +1314,10 @@ pub fn aya::maps::XskMap<T>::try_from(value: U) -> core::result::Result<T, <T as
 impl<T, U> core::convert::TryInto<U> for aya::maps::XskMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::XskMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::XskMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::XskMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::XskMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::XskMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::XskMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::XskMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::XskMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::XskMap<T> where T: ?core::marker::Sized
@@ -1150,11 +1328,13 @@ impl<T> core::convert::From<T> for aya::maps::XskMap<T>
 pub fn aya::maps::XskMap<T>::from(t: T) -> T
 pub enum aya::maps::Map
 pub aya::maps::Map::Array(aya::maps::MapData)
+pub aya::maps::Map::ArrayOfMaps(aya::maps::MapData)
 pub aya::maps::Map::BloomFilter(aya::maps::MapData)
 pub aya::maps::Map::CpuMap(aya::maps::MapData)
 pub aya::maps::Map::DevMap(aya::maps::MapData)
 pub aya::maps::Map::DevMapHash(aya::maps::MapData)
 pub aya::maps::Map::HashMap(aya::maps::MapData)
+pub aya::maps::Map::HashOfMaps(aya::maps::MapData)
 pub aya::maps::Map::LpmTrie(aya::maps::MapData)
 pub aya::maps::Map::LruHashMap(aya::maps::MapData)
 pub aya::maps::Map::PerCpuArray(aya::maps::MapData)
@@ -1172,6 +1352,7 @@ pub aya::maps::Map::StackTraceMap(aya::maps::MapData)
 pub aya::maps::Map::Unsupported(aya::maps::MapData)
 pub aya::maps::Map::XskMap(aya::maps::MapData)
 impl aya::maps::Map
+pub const fn aya::maps::Map::fd(&self) -> &aya::maps::MapFd
 pub fn aya::maps::Map::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<Self, aya::maps::MapError>
 pub fn aya::maps::Map::pin<P: core::convert::AsRef<std::path::Path>>(&self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl core::convert::TryFrom<aya::maps::Map> for aya::maps::CpuMap<aya::maps::MapData>
@@ -1221,6 +1402,12 @@ pub fn aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::try
 impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>
 pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError
 pub fn aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, K: aya::Pod, V> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, K: aya::Pod, V> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::PerCpuArray<&'a aya::maps::MapData, V>
 pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -1263,6 +1450,12 @@ pub fn aya::maps::sk_storage::SkStorage<&'a mut aya::maps::MapData, V>::try_from
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>
 pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, V> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, V> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
 impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::CpuMap<&'a aya::maps::MapData>
 pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::maps::MapError
 pub fn aya::maps::CpuMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -1326,6 +1519,9 @@ pub fn aya::maps::hash_map::PerCpuHashMap<aya::maps::MapData, K, V>::try_from(ma
 impl<K: aya::Pod, V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>
 pub type aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>::Error = aya::maps::MapError
 pub fn aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<K: aya::Pod, V> core::convert::TryFrom<aya::maps::Map> for aya::maps::HashOfMaps<aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<aya::maps::MapData, K, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
 impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::PerCpuArray<aya::maps::MapData, V>
 pub type aya::maps::PerCpuArray<aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::PerCpuArray<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -1347,6 +1543,9 @@ pub fn aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::try_from(map: ay
 impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::stack::Stack<aya::maps::MapData, V>
 pub type aya::maps::stack::Stack<aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::stack::Stack<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<V> core::convert::TryFrom<aya::maps::Map> for aya::maps::ArrayOfMaps<aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
 impl core::marker::Freeze for aya::maps::Map
 impl core::marker::Send for aya::maps::Map
 impl core::marker::Sync for aya::maps::Map
@@ -1375,6 +1574,9 @@ pub aya::maps::MapError::CreateError
 pub aya::maps::MapError::CreateError::io_error: std::io::error::Error
 pub aya::maps::MapError::CreateError::name: alloc::string::String
 pub aya::maps::MapError::ElementNotFound
+pub aya::maps::MapError::InnerMapNotFound
+pub aya::maps::MapError::InnerMapNotFound::inner_name: alloc::string::String
+pub aya::maps::MapError::InnerMapNotFound::name: alloc::string::String
 pub aya::maps::MapError::InvalidKeySize
 pub aya::maps::MapError::InvalidKeySize::expected: usize
 pub aya::maps::MapError::InvalidKeySize::size: usize
@@ -1387,6 +1589,8 @@ pub aya::maps::MapError::InvalidValueSize::expected: usize
 pub aya::maps::MapError::InvalidValueSize::size: usize
 pub aya::maps::MapError::IoError(std::io::error::Error)
 pub aya::maps::MapError::KeyNotFound
+pub aya::maps::MapError::MissingInnerMapBinding
+pub aya::maps::MapError::MissingInnerMapBinding::name: alloc::string::String
 pub aya::maps::MapError::OutOfBounds
 pub aya::maps::MapError::OutOfBounds::index: u32
 pub aya::maps::MapError::OutOfBounds::max_entries: u32
@@ -1526,6 +1730,8 @@ impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::array:
 pub fn aya::maps::array::Array<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::array::Array<T, V>
 pub fn aya::maps::array::Array<T, V>::set(&mut self, index: u32, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::array::Array<aya::maps::MapData, V>
+pub fn aya::maps::array::Array<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::array::Array<&'a aya::maps::MapData, V>
 pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::array::Array<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -1553,6 +1759,10 @@ pub fn aya::maps::array::Array<T, V>::try_from(value: U) -> core::result::Result
 impl<T, U> core::convert::TryInto<U> for aya::maps::array::Array<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::array::Array<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::array::Array<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::array::Array<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::array::Array<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::array::Array<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::array::Array<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::array::Array<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::array::Array<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::array::Array<T, V> where T: ?core::marker::Sized
@@ -1561,6 +1771,50 @@ impl<T> core::borrow::BorrowMut<T> for aya::maps::array::Array<T, V> where T: ?c
 pub fn aya::maps::array::Array<T, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::array::Array<T, V>
 pub fn aya::maps::array::Array<T, V>::from(t: T) -> T
+pub struct aya::maps::ArrayOfMaps<T, V>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::maps::FromMapData> aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::get(&self, index: &u32, flags: u64) -> core::result::Result<V, aya::maps::MapError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V> aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::is_empty(&self) -> bool
+pub fn aya::maps::ArrayOfMaps<T, V>::len(&self) -> u32
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::maps::InnerMap> aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::set(&mut self, index: u32, value: &V, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V> aya::maps::ArrayOfMaps<aya::maps::MapData, V>
+pub fn aya::maps::ArrayOfMaps<aya::maps::MapData, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
+impl<'a, V> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, V> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T: core::fmt::Debug, V> core::fmt::Debug for aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V> core::convert::TryFrom<aya::maps::Map> for aya::maps::ArrayOfMaps<aya::maps::MapData, V>
+pub type aya::maps::ArrayOfMaps<aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::ArrayOfMaps<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T, V> core::marker::Freeze for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Freeze
+impl<T, V> core::marker::Send for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Send, V: core::marker::Send
+impl<T, V> core::marker::Sync for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Sync, V: core::marker::Sync
+impl<T, V> core::marker::Unpin for aya::maps::ArrayOfMaps<T, V> where T: core::marker::Unpin, V: core::marker::Unpin
+impl<T, V> core::marker::UnsafeUnpin for aya::maps::ArrayOfMaps<T, V> where T: core::marker::UnsafeUnpin
+impl<T, V> core::panic::unwind_safe::RefUnwindSafe for aya::maps::ArrayOfMaps<T, V> where T: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, V> core::panic::unwind_safe::UnwindSafe for aya::maps::ArrayOfMaps<T, V> where T: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya::maps::ArrayOfMaps<T, V> where U: core::convert::From<T>
+pub fn aya::maps::ArrayOfMaps<T, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya::maps::ArrayOfMaps<T, V> where U: core::convert::Into<T>
+pub type aya::maps::ArrayOfMaps<T, V>::Error = core::convert::Infallible
+pub fn aya::maps::ArrayOfMaps<T, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya::maps::ArrayOfMaps<T, V> where U: core::convert::TryFrom<T>
+pub type aya::maps::ArrayOfMaps<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya::maps::ArrayOfMaps<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya::maps::ArrayOfMaps<T, V> where T: 'static + ?core::marker::Sized
+pub fn aya::maps::ArrayOfMaps<T, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya::maps::ArrayOfMaps<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::ArrayOfMaps<T, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya::maps::ArrayOfMaps<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::ArrayOfMaps<T, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya::maps::ArrayOfMaps<T, V>
+pub fn aya::maps::ArrayOfMaps<T, V>::from(t: T) -> T
 pub struct aya::maps::BloomFilter<T, V: aya::Pod>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::bloom_filter::BloomFilter<T, V>
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::contains(&self, value: &mut V, flags: u64) -> core::result::Result<(), aya::maps::MapError>
@@ -1568,6 +1822,8 @@ impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::bloom_
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::bloom_filter::BloomFilter<T, V>
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::insert(&mut self, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::bloom_filter::BloomFilter<aya::maps::MapData, V>
+pub fn aya::maps::bloom_filter::BloomFilter<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>
 pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -1594,6 +1850,10 @@ pub fn aya::maps::bloom_filter::BloomFilter<T, V>::try_from(value: U) -> core::r
 impl<T, U> core::convert::TryInto<U> for aya::maps::bloom_filter::BloomFilter<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::bloom_filter::BloomFilter<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::bloom_filter::BloomFilter<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::bloom_filter::BloomFilter<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::bloom_filter::BloomFilter<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::bloom_filter::BloomFilter<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::bloom_filter::BloomFilter<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::bloom_filter::BloomFilter<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::bloom_filter::BloomFilter<T, V> where T: ?core::marker::Sized
@@ -1635,6 +1895,10 @@ pub fn aya::maps::CpuMap<T>::try_from(value: U) -> core::result::Result<T, <T as
 impl<T, U> core::convert::TryInto<U> for aya::maps::CpuMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::CpuMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::CpuMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::CpuMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::CpuMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::CpuMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::CpuMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::CpuMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::CpuMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::CpuMap<T> where T: ?core::marker::Sized
@@ -1676,6 +1940,10 @@ pub fn aya::maps::DevMap<T>::try_from(value: U) -> core::result::Result<T, <T as
 impl<T, U> core::convert::TryInto<U> for aya::maps::DevMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::DevMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::DevMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::DevMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::DevMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::DevMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::DevMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::DevMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::DevMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::DevMap<T> where T: ?core::marker::Sized
@@ -1722,6 +1990,10 @@ pub fn aya::maps::DevMapHash<T>::try_from(value: U) -> core::result::Result<T, <
 impl<T, U> core::convert::TryInto<U> for aya::maps::DevMapHash<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::DevMapHash<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::DevMapHash<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::DevMapHash<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::DevMapHash<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::DevMapHash<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::DevMapHash<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::DevMapHash<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::DevMapHash<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::DevMapHash<T> where T: ?core::marker::Sized
@@ -1731,6 +2003,8 @@ pub fn aya::maps::DevMapHash<T>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::DevMapHash<T>
 pub fn aya::maps::DevMapHash<T>::from(t: T) -> T
 pub struct aya::maps::HashMap<T, K, V>
+impl<K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap<aya::maps::MapData, K, V>
+pub fn aya::maps::hash_map::HashMap<aya::maps::MapData, K, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap<T, K, V>
 pub fn aya::maps::hash_map::HashMap<T, K, V>::get(&self, key: &K, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::hash_map::HashMap<T, K, V>::iter(&self) -> aya::maps::MapIter<'_, K, V, Self>
@@ -1773,6 +2047,10 @@ pub fn aya::maps::hash_map::HashMap<T, K, V>::try_from(value: U) -> core::result
 impl<T, U> core::convert::TryInto<U> for aya::maps::hash_map::HashMap<T, K, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::hash_map::HashMap<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::hash_map::HashMap<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::hash_map::HashMap<T, K, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::hash_map::HashMap<T, K, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::hash_map::HashMap<T, K, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::hash_map::HashMap<T, K, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::hash_map::HashMap<T, K, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::hash_map::HashMap<T, K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::hash_map::HashMap<T, K, V> where T: ?core::marker::Sized
@@ -1781,7 +2059,54 @@ impl<T> core::borrow::BorrowMut<T> for aya::maps::hash_map::HashMap<T, K, V> whe
 pub fn aya::maps::hash_map::HashMap<T, K, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::hash_map::HashMap<T, K, V>
 pub fn aya::maps::hash_map::HashMap<T, K, V>::from(t: T) -> T
+pub struct aya::maps::HashOfMaps<T, K, V>
+impl<K: aya::Pod, V> aya::maps::HashOfMaps<aya::maps::MapData, K, V>
+pub fn aya::maps::HashOfMaps<aya::maps::MapData, K, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::maps::FromMapData> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::get(&self, key: &K, flags: u64) -> core::result::Result<V, aya::maps::MapError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::keys(&self) -> aya::maps::MapKeys<'_, K>
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, K: aya::Pod, V: aya::maps::InnerMap> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::insert(&mut self, key: impl core::borrow::Borrow<K>, value: &V, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, K: aya::Pod, V> aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError>
+impl<'a, K: aya::Pod, V> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<'a, K: aya::Pod, V> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<K: aya::Pod, V> core::convert::TryFrom<aya::maps::Map> for aya::maps::HashOfMaps<aya::maps::MapData, K, V>
+pub type aya::maps::HashOfMaps<aya::maps::MapData, K, V>::Error = aya::maps::MapError
+pub fn aya::maps::HashOfMaps<aya::maps::MapData, K, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T: core::fmt::Debug, K, V> core::fmt::Debug for aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<T, K, V> core::marker::Freeze for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Freeze
+impl<T, K, V> core::marker::Send for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Send, K: core::marker::Send, V: core::marker::Send
+impl<T, K, V> core::marker::Sync for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Sync, K: core::marker::Sync, V: core::marker::Sync
+impl<T, K, V> core::marker::Unpin for aya::maps::HashOfMaps<T, K, V> where T: core::marker::Unpin, K: core::marker::Unpin, V: core::marker::Unpin
+impl<T, K, V> core::marker::UnsafeUnpin for aya::maps::HashOfMaps<T, K, V> where T: core::marker::UnsafeUnpin
+impl<T, K, V> core::panic::unwind_safe::RefUnwindSafe for aya::maps::HashOfMaps<T, K, V> where T: core::panic::unwind_safe::RefUnwindSafe, K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, K, V> core::panic::unwind_safe::UnwindSafe for aya::maps::HashOfMaps<T, K, V> where T: core::panic::unwind_safe::UnwindSafe, K: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya::maps::HashOfMaps<T, K, V> where U: core::convert::From<T>
+pub fn aya::maps::HashOfMaps<T, K, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya::maps::HashOfMaps<T, K, V> where U: core::convert::Into<T>
+pub type aya::maps::HashOfMaps<T, K, V>::Error = core::convert::Infallible
+pub fn aya::maps::HashOfMaps<T, K, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya::maps::HashOfMaps<T, K, V> where U: core::convert::TryFrom<T>
+pub type aya::maps::HashOfMaps<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya::maps::HashOfMaps<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya::maps::HashOfMaps<T, K, V> where T: 'static + ?core::marker::Sized
+pub fn aya::maps::HashOfMaps<T, K, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya::maps::HashOfMaps<T, K, V> where T: ?core::marker::Sized
+pub fn aya::maps::HashOfMaps<T, K, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya::maps::HashOfMaps<T, K, V> where T: ?core::marker::Sized
+pub fn aya::maps::HashOfMaps<T, K, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya::maps::HashOfMaps<T, K, V>
+pub fn aya::maps::HashOfMaps<T, K, V>::from(t: T) -> T
 pub struct aya::maps::LpmTrie<T, K, V>
+impl<K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>
+pub fn aya::maps::lpm_trie::LpmTrie<aya::maps::MapData, K, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie<T, K, V>
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::get(&self, key: &aya::maps::lpm_trie::Key<K>, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::iter(&self) -> aya::maps::MapIter<'_, aya::maps::lpm_trie::Key<K>, V, Self>
@@ -1824,6 +2149,10 @@ pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::try_from(value: U) -> core::result
 impl<T, U> core::convert::TryInto<U> for aya::maps::lpm_trie::LpmTrie<T, K, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::lpm_trie::LpmTrie<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::lpm_trie::LpmTrie<T, K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::lpm_trie::LpmTrie<T, K, V> where T: ?core::marker::Sized
@@ -1858,6 +2187,10 @@ pub fn aya::maps::MapData::try_from(value: U) -> core::result::Result<T, <T as c
 impl<T, U> core::convert::TryInto<U> for aya::maps::MapData where U: core::convert::TryFrom<T>
 pub type aya::maps::MapData::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::MapData::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::MapData where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::MapData::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::MapData where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::MapData::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::MapData where T: 'static + ?core::marker::Sized
 pub fn aya::maps::MapData::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::MapData where T: ?core::marker::Sized
@@ -1867,6 +2200,8 @@ pub fn aya::maps::MapData::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::MapData
 pub fn aya::maps::MapData::from(t: T) -> T
 pub struct aya::maps::MapFd
+impl aya::maps::MapFd
+pub fn aya::maps::MapFd::try_clone(&self) -> std::io::error::Result<Self>
 impl core::fmt::Debug for aya::maps::MapFd
 pub fn aya::maps::MapFd::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 impl std::os::fd::owned::AsFd for aya::maps::MapFd
@@ -1886,6 +2221,8 @@ pub fn aya::maps::MapFd::try_from(value: U) -> core::result::Result<T, <T as cor
 impl<T, U> core::convert::TryInto<U> for aya::maps::MapFd where U: core::convert::TryFrom<T>
 pub type aya::maps::MapFd::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::MapFd::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::InnerMap for aya::maps::MapFd where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::MapFd::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::MapFd where T: 'static + ?core::marker::Sized
 pub fn aya::maps::MapFd::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::MapFd where T: ?core::marker::Sized
@@ -2003,6 +2340,8 @@ impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::PerCpu
 pub fn aya::maps::PerCpuArray<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::PerCpuArray<T, V>
 pub fn aya::maps::PerCpuArray<T, V>::set(&mut self, index: u32, values: aya::maps::PerCpuValues<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::PerCpuArray<aya::maps::MapData, V>
+pub fn aya::maps::PerCpuArray<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::PerCpuArray<&'a aya::maps::MapData, V>
 pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -2030,6 +2369,10 @@ pub fn aya::maps::PerCpuArray<T, V>::try_from(value: U) -> core::result::Result<
 impl<T, U> core::convert::TryInto<U> for aya::maps::PerCpuArray<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::PerCpuArray<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::PerCpuArray<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::PerCpuArray<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::PerCpuArray<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::PerCpuArray<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::PerCpuArray<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::PerCpuArray<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::PerCpuArray<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::PerCpuArray<T, V> where T: ?core::marker::Sized
@@ -2039,6 +2382,8 @@ pub fn aya::maps::PerCpuArray<T, V>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::PerCpuArray<T, V>
 pub fn aya::maps::PerCpuArray<T, V>::from(t: T) -> T
 pub struct aya::maps::PerCpuHashMap<T, K: aya::Pod, V: aya::Pod>
+impl<K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap<aya::maps::MapData, K, V>
+pub fn aya::maps::hash_map::PerCpuHashMap<aya::maps::MapData, K, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap<T, K, V>
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::get(&self, key: &K, flags: u64) -> core::result::Result<aya::maps::PerCpuValues<V>, aya::maps::MapError>
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::iter(&self) -> aya::maps::MapIter<'_, K, aya::maps::PerCpuValues<V>, Self>
@@ -2079,6 +2424,10 @@ pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::try_from(value: U) -> core::
 impl<T, U> core::convert::TryInto<U> for aya::maps::hash_map::PerCpuHashMap<T, K, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::hash_map::PerCpuHashMap<T, K, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::hash_map::PerCpuHashMap<T, K, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::hash_map::PerCpuHashMap<T, K, V> where T: ?core::marker::Sized
@@ -2156,6 +2505,10 @@ pub fn aya::maps::perf::PerfEventArray<T>::try_from(value: U) -> core::result::R
 impl<T, U> core::convert::TryInto<U> for aya::maps::perf::PerfEventArray<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::perf::PerfEventArray<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::perf::PerfEventArray<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::perf::PerfEventArray<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::perf::PerfEventArray<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::perf::PerfEventArray<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::perf::PerfEventArray<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::perf::PerfEventArray<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::perf::PerfEventArray<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::perf::PerfEventArray<T> where T: ?core::marker::Sized
@@ -2212,6 +2565,8 @@ pub fn aya::maps::queue::Queue<T, V>::pin<P: core::convert::AsRef<std::path::Pat
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::queue::Queue<T, V>
 pub fn aya::maps::queue::Queue<T, V>::pop(&mut self, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::queue::Queue<T, V>::push(&mut self, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::queue::Queue<aya::maps::MapData, V>
+pub fn aya::maps::queue::Queue<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::queue::Queue<&'a aya::maps::MapData, V>
 pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::queue::Queue<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -2236,6 +2591,10 @@ pub fn aya::maps::queue::Queue<T, V>::try_from(value: U) -> core::result::Result
 impl<T, U> core::convert::TryInto<U> for aya::maps::queue::Queue<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::queue::Queue<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::queue::Queue<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::queue::Queue<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::queue::Queue<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::queue::Queue<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::queue::Queue<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::queue::Queue<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::queue::Queue<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::queue::Queue<T, V> where T: ?core::marker::Sized
@@ -2275,6 +2634,10 @@ pub fn aya::maps::ring_buf::RingBuf<T>::try_from(value: U) -> core::result::Resu
 impl<T, U> core::convert::TryInto<U> for aya::maps::ring_buf::RingBuf<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::ring_buf::RingBuf<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::ring_buf::RingBuf<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::ring_buf::RingBuf<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::ring_buf::RingBuf<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::ring_buf::RingBuf<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::ring_buf::RingBuf<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::ring_buf::RingBuf<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::ring_buf::RingBuf<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::ring_buf::RingBuf<T> where T: ?core::marker::Sized
@@ -2317,6 +2680,10 @@ pub fn aya::maps::sk_storage::SkStorage<T, V>::try_from(value: U) -> core::resul
 impl<T, U> core::convert::TryInto<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::sk_storage::SkStorage<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::sk_storage::SkStorage<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::sk_storage::SkStorage<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::sk_storage::SkStorage<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::sk_storage::SkStorage<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::sk_storage::SkStorage<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::sk_storage::SkStorage<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::sk_storage::SkStorage<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::sk_storage::SkStorage<T, V> where T: ?core::marker::Sized
@@ -2367,6 +2734,10 @@ pub fn aya::maps::SockHash<T, K>::try_from(value: U) -> core::result::Result<T,
 impl<T, U> core::convert::TryInto<U> for aya::maps::SockHash<T, K> where U: core::convert::TryFrom<T>
 pub type aya::maps::SockHash<T, K>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::SockHash<T, K>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::SockHash<T, K> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::SockHash<T, K>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::SockHash<T, K> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::SockHash<T, K>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::SockHash<T, K> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::SockHash<T, K>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::SockHash<T, K> where T: ?core::marker::Sized
@@ -2408,6 +2779,10 @@ pub fn aya::maps::SockMap<T>::try_from(value: U) -> core::result::Result<T, <T a
 impl<T, U> core::convert::TryInto<U> for aya::maps::SockMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::SockMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::SockMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::SockMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::SockMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::SockMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::SockMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::SockMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::SockMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::SockMap<T> where T: ?core::marker::Sized
@@ -2424,6 +2799,8 @@ pub fn aya::maps::stack::Stack<T, V>::pin<P: core::convert::AsRef<std::path::Pat
 impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::stack::Stack<T, V>
 pub fn aya::maps::stack::Stack<T, V>::pop(&mut self, flags: u64) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::stack::Stack<T, V>::push(&mut self, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+impl<V: aya::Pod> aya::maps::stack::Stack<aya::maps::MapData, V>
+pub fn aya::maps::stack::Stack<aya::maps::MapData, V>::create(max_entries: u32, flags: u32) -> core::result::Result<Self, aya::maps::MapError>
 impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack::Stack<&'a aya::maps::MapData, V>
 pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::stack::Stack<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -2448,6 +2825,10 @@ pub fn aya::maps::stack::Stack<T, V>::try_from(value: U) -> core::result::Result
 impl<T, U> core::convert::TryInto<U> for aya::maps::stack::Stack<T, V> where U: core::convert::TryFrom<T>
 pub type aya::maps::stack::Stack<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::stack::Stack<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::stack::Stack<T, V> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::stack::Stack<T, V>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::stack::Stack<T, V> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::stack::Stack<T, V>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::stack::Stack<T, V> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::stack::Stack<T, V>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::stack::Stack<T, V> where T: ?core::marker::Sized
@@ -2498,6 +2879,10 @@ pub fn aya::maps::stack_trace::StackTraceMap<T>::try_from(value: U) -> core::res
 impl<T, U> core::convert::TryInto<U> for aya::maps::stack_trace::StackTraceMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::stack_trace::StackTraceMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::stack_trace::StackTraceMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::stack_trace::StackTraceMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::stack_trace::StackTraceMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::stack_trace::StackTraceMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::stack_trace::StackTraceMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::stack_trace::StackTraceMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::stack_trace::StackTraceMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::stack_trace::StackTraceMap<T> where T: ?core::marker::Sized
@@ -2538,6 +2923,10 @@ pub fn aya::maps::XskMap<T>::try_from(value: U) -> core::result::Result<T, <T as
 impl<T, U> core::convert::TryInto<U> for aya::maps::XskMap<T> where U: core::convert::TryFrom<T>
 pub type aya::maps::XskMap<T>::Error = <U as core::convert::TryFrom<T>>::Error
 pub fn aya::maps::XskMap<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> aya::maps::FromMapData for aya::maps::XskMap<T> where T: aya::maps::sealed::FromMapData
+pub fn aya::maps::XskMap<T>::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+impl<T> aya::maps::InnerMap for aya::maps::XskMap<T> where T: aya::maps::sealed::InnerMap
+pub fn aya::maps::XskMap<T>::fd(&self) -> &aya::maps::MapFd
 impl<T> core::any::Any for aya::maps::XskMap<T> where T: 'static + ?core::marker::Sized
 pub fn aya::maps::XskMap<T>::type_id(&self) -> core::any::TypeId
 impl<T> core::borrow::Borrow<T> for aya::maps::XskMap<T> where T: ?core::marker::Sized
@@ -2546,6 +2935,14 @@ impl<T> core::borrow::BorrowMut<T> for aya::maps::XskMap<T> where T: ?core::mark
 pub fn aya::maps::XskMap<T>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::XskMap<T>
 pub fn aya::maps::XskMap<T>::from(t: T) -> T
+pub trait aya::maps::FromMapData: core::marker::Sized + aya::maps::sealed::FromMapData
+pub fn aya::maps::FromMapData::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<Self, aya::maps::MapError>
+impl<T: aya::maps::sealed::FromMapData> aya::maps::FromMapData for T
+pub fn T::from_map_data(map_data: aya::maps::MapData) -> core::result::Result<T, aya::maps::MapError>
+pub trait aya::maps::InnerMap: aya::maps::sealed::InnerMap
+pub fn aya::maps::InnerMap::fd(&self) -> &aya::maps::MapFd
+impl<T: aya::maps::sealed::InnerMap> aya::maps::InnerMap for T
+pub fn T::fd(&self) -> &aya::maps::MapFd
 pub trait aya::maps::IterableMap<K: aya::Pod, V>
 pub fn aya::maps::IterableMap::get(&self, key: &K) -> core::result::Result<V, aya::maps::MapError>
 pub fn aya::maps::IterableMap::map(&self) -> &aya::maps::MapData