//! File backend implementation that can be backed by the [Secret portal](https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.portal.Secret.html).

//!

//! ```no_run

//! use oo7::{Secret, file::UnlockedKeyring};

//!

//! # async fn run() -> oo7::Result<()> {

//! let keyring = UnlockedKeyring::load("default.keyring", Some(Secret::text("some_text"))).await?;

//! keyring

//!     .create_item("My Label", &[("account", "alice")], "My Password", true)

//!     .await?;

//!

//! let items = keyring.search_items(&[("account", "alice")]).await?;

//! assert_eq!(items[0].secret(), oo7::Secret::blob("My Password"));

//!

//! keyring.delete(&[("account", "alice")]).await?;

//! #   Ok(())

//! # }

//! ```

#[cfg(feature = "unstable")]

#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]

pub mod api;

#[cfg(not(feature = "unstable"))]

pub(crate) mod api;

mod error;

mod locked_item;

mod locked_keyring;

mod unlocked_item;

mod unlocked_keyring;

pub use error::{Error, InvalidItemError, WeakKeyError};

pub use locked_item::LockedItem;

pub use locked_keyring::LockedKeyring;

pub use unlocked_item::UnlockedItem;

pub use unlocked_keyring::{ItemDefinition, UnlockedKeyring};

use crate::{AsAttributes, Key, Secret};

#[derive(Debug)]

pub enum Item {

    Locked(LockedItem),

    Unlocked(UnlockedItem),

}

impl From<UnlockedItem> for Item {

    }

}

impl From<LockedItem> for Item {

    }

}

impl Item {

    }

            _ => panic!("The item is locked"),

        }

    }

            _ => panic!("The item is locked"),

        }

    }

            _ => panic!("The item is unlocked"),

        }

    }

    /// Check if this item matches the given attributes

                })

            }

        }

    }

    /// Check if this item has exactly the given attributes.

        &self,

        attributes: &impl AsAttributes,

        key: Option<&Key>,

    ) -> bool {

        }

    }

}

#[derive(Debug)]

pub enum Keyring {

    Locked(LockedKeyring),

    Unlocked(UnlockedKeyring),

}

impl From<LockedKeyring> for Keyring {

    }

}

impl From<UnlockedKeyring> for Keyring {

    }

}

impl Keyring {

    /// Validate that a secret can decrypt the items in this keyring.

    #[cfg_attr(feature = "tracing", tracing::instrument(skip(self, secret)))]

        }

    }

        }

    }

    /// Get the modification timestamp

        }

    }

    /// Get the creation timestamp from the filesystem if the keyring has an

    /// associated file.

        #[cfg(feature = "tokio")]

        let metadata = tokio::fs::metadata(path).await.ok()?;

        #[cfg(feature = "async-std")]

        let metadata = async_fs::metadata(path).await.ok()?;

            .created()

            .ok()

    }

        }

    }

    /// Return the associated file if any.

        }

    }

    }

            _ => panic!("The keyring is locked"),

        }

    }

            _ => panic!("The keyring is unlocked"),

        }

    }

}