remove repo dir

src/actor_store/blob/store.rs

···
+use anyhow::Result;
+use atrium_repo::Cid;
+use std::fmt::Debug;
+
+/// BlobStream
+/// A stream of blob data.
+pub(crate) struct BlobStream(Box<dyn std::io::Read + Send>);
+impl Debug for BlobStream {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BlobStream").finish()
+    }
+}
+
+pub(crate) struct BlobStorePlaceholder;
+pub(crate) trait BlobStore {
+    async fn put_temp(&self, bytes: &[u8]) -> Result<String>; // bytes: Uint8Array | stream.Readable
+    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()>;
+    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()>;
+    async fn quarantine(&self, cid: Cid) -> Result<()>;
+    async fn unquarantine(&self, cid: Cid) -> Result<()>;
+    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>>;
+    async fn get_stream(&self, cid: Cid) -> Result<BlobStream>; // Promise<stream.Readable>
+    async fn has_temp(&self, key: &str) -> Result<bool>;
+    async fn has_stored(&self, cid: Cid) -> Result<bool>;
+    async fn delete(&self, cid: Cid) -> Result<()>;
+    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()>;
+}
+impl BlobStore for BlobStorePlaceholder {
+    async fn put_temp(&self, bytes: &[u8]) -> Result<String> {
+        // Implementation here
+        todo!();
+        Ok("temp_key".to_string())
+    }
+
+    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()> {
+        // Implementation here
+        todo!();
+        Ok(())
+    }
+
+    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()> {
+        // Implementation here
+        todo!();
+        Ok(())
+    }
+
+    async fn quarantine(&self, cid: Cid) -> Result<()> {
+        // Implementation here
+        todo!();
+        Ok(())
+    }
+
+    async fn unquarantine(&self, cid: Cid) -> Result<()> {
+        // Implementation here
+        todo!();
+        Ok(())
+    }
+
+    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>> {
+        // Implementation here
+        todo!();
+        Ok(vec![])
+    }
+
+    async fn get_stream(&self, cid: Cid) -> Result<BlobStream> {
+        // Implementation here
+        todo!();
+        Ok(BlobStream(Box::new(std::io::empty())))
+    }
+
+    async fn has_temp(&self, key: &str) -> Result<bool> {
+        // Implementation here
+        todo!();
+        Ok(true)
+    }
+
+    async fn has_stored(&self, cid: Cid) -> Result<bool> {
+        // Implementation here
+        todo!();
+        Ok(true)
+    }
+    async fn delete(&self, cid: Cid) -> Result<()> {
+        // Implementation here
+        todo!();
+        Ok(())
+    }
+    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
+        // Implementation here
+        todo!();
+        Ok(())
+    }
+}

src/actor_store/prepared_write.rs

···
+use rsky_repo::types::{
+    CommitAction, PreparedBlobRef, PreparedCreateOrUpdate, PreparedDelete, WriteOpAction,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub enum PreparedWrite {
+    Create(PreparedCreateOrUpdate),
+    Update(PreparedCreateOrUpdate),
+    Delete(PreparedDelete),
+}
+
+impl PreparedWrite {
+    pub fn uri(&self) -> &String {
+        match self {
+            PreparedWrite::Create(w) => &w.uri,
+            PreparedWrite::Update(w) => &w.uri,
+            PreparedWrite::Delete(w) => &w.uri,
+        }
+    }
+
+    pub fn cid(&self) -> Option<Cid> {
+        match self {
+            PreparedWrite::Create(w) => Some(w.cid),
+            PreparedWrite::Update(w) => Some(w.cid),
+            PreparedWrite::Delete(_) => None,
+        }
+    }
+
+    pub fn swap_cid(&self) -> &Option<Cid> {
+        match self {
+            PreparedWrite::Create(w) => &w.swap_cid,
+            PreparedWrite::Update(w) => &w.swap_cid,
+            PreparedWrite::Delete(w) => &w.swap_cid,
+        }
+    }
+
+    pub fn action(&self) -> &WriteOpAction {
+        match self {
+            PreparedWrite::Create(w) => &w.action,
+            PreparedWrite::Update(w) => &w.action,
+            PreparedWrite::Delete(w) => &w.action,
+        }
+    }
+
+    /// TEQ: Add blobs() impl
+    pub fn blobs(&self) -> Option<&Vec<PreparedBlobRef>> {
+        match self {
+            PreparedWrite::Create(w) => Some(&w.blobs),
+            PreparedWrite::Update(w) => Some(&w.blobs),
+            PreparedWrite::Delete(_) => None,
+        }
+    }
+}
+
+impl From<&PreparedWrite> for CommitAction {
+    fn from(value: &PreparedWrite) -> Self {
+        match value {
+            &PreparedWrite::Create(_) => CommitAction::Create,
+            &PreparedWrite::Update(_) => CommitAction::Update,
+            &PreparedWrite::Delete(_) => CommitAction::Delete,
+        }
+    }
+}

src/repo/block_map.rs

···
-//! BlockMap impl
-//! Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/block_map.rs
-//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
-//! Reimplemented here because of conflicting dependencies between atrium and rsky
-
-use anyhow::Result;
-use atrium_repo::Cid;
-use serde::{Deserialize, Serialize};
-use sha2::Digest;
-use std::collections::{BTreeMap, HashSet};
-use std::str::FromStr;
-
-/// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/cid_set.rs
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub(crate) struct CidSet {
-    pub set: HashSet<String>,
-}
-impl CidSet {
-    pub(crate) fn new(arr: Option<Vec<Cid>>) -> Self {
-        let str_arr: Vec<String> = arr
-            .unwrap_or(Vec::new())
-            .into_iter()
-            .map(|cid| cid.to_string())
-            .collect::<Vec<String>>();
-        CidSet {
-            set: HashSet::from_iter(str_arr),
-        }
-    }
-
-    pub(crate) fn add(&mut self, cid: Cid) -> () {
-        let _ = &self.set.insert(cid.to_string());
-        ()
-    }
-
-    pub(crate) fn add_set(&mut self, to_merge: CidSet) -> () {
-        for cid in to_merge.to_list() {
-            let _ = &self.add(cid);
-        }
-        ()
-    }
-
-    pub(crate) fn subtract_set(&mut self, to_subtract: CidSet) -> () {
-        for cid in to_subtract.to_list() {
-            self.delete(cid);
-        }
-        ()
-    }
-
-    pub(crate) fn delete(&mut self, cid: Cid) -> () {
-        self.set.remove(&cid.to_string());
-        ()
-    }
-
-    pub(crate) fn has(&self, cid: Cid) -> bool {
-        self.set.contains(&cid.to_string())
-    }
-
-    pub(crate) fn size(&self) -> usize {
-        self.set.len()
-    }
-
-    pub(crate) fn clear(mut self) -> () {
-        self.set.clear();
-        ()
-    }
-
-    pub(crate) fn to_list(&self) -> Vec<Cid> {
-        self.set
-            .clone()
-            .into_iter()
-            .filter_map(|cid| match Cid::from_str(&cid) {
-                Ok(r) => Some(r),
-                Err(_) => None,
-            })
-            .collect::<Vec<Cid>>()
-    }
-}
-
-/// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-common/src/lib.rs#L57
-pub(crate) fn struct_to_cbor<T: Serialize>(obj: &T) -> Result<Vec<u8>> {
-    Ok(serde_ipld_dagcbor::to_vec(obj)?)
-}
-
-/// Ref: https://github.com/blacksky-algorithms/rsky/blob/37954845d06aaafea2b914d9096a1657abfc8d75/rsky-common/src/ipld.rs
-/// Create a CID for CBOR-encoded data
-pub(crate) fn cid_for_cbor<T: Serialize>(data: &T) -> Result<Cid> {
-    let bytes = struct_to_cbor(data)?;
-    let multihash = atrium_repo::Multihash::wrap(
-        atrium_repo::blockstore::SHA2_256,
-        &sha2::Sha256::digest(&bytes),
-    )
-    .expect("valid multihash");
-
-    // Use the constant for DAG_CBOR (0x71) directly instead of converting from DagCborCodec
-    Ok(Cid::new_v1(0x71, multihash))
-}
-
-/// Create a CID from a SHA-256 hash with the specified codec
-pub(crate) fn sha256_to_cid(hash: Vec<u8>, codec: u64) -> Cid {
-    let multihash = atrium_repo::Multihash::wrap(atrium_repo::blockstore::SHA2_256, &hash)
-        .expect("valid multihash");
-
-    Cid::new_v1(codec, multihash)
-}
-
-/// Create a CID from a raw SHA-256 hash (using raw codec 0x55)
-pub(crate) fn sha256_raw_to_cid(hash: Vec<u8>) -> Cid {
-    sha256_to_cid(hash, 0x55) // 0x55 is the codec for raw
-}
-
-/// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/types.rs#L436
-pub(crate) type CarBlock = CidAndBytes;
-pub(crate) struct CidAndBytes {
-    pub cid: Cid,
-    pub bytes: Vec<u8>,
-}
-
-// Thinly wraps a Vec<u8>
-// The #[serde(transparent)] attribute ensures that during (de)serialization
-// this newtype is treated the same as the underlying Vec<u8>.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(transparent)]
-pub(crate) struct Bytes(#[serde(with = "serde_bytes")] pub Vec<u8>);
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub(crate) struct BlockMap {
-    pub map: BTreeMap<String, Bytes>,
-}
-
-impl BlockMap {
-    pub(crate) fn new() -> Self {
-        BlockMap {
-            map: BTreeMap::new(),
-        }
-    }
-
-    pub(crate) fn add<T: Serialize>(&mut self, value: T) -> Result<Cid> {
-        let cid = cid_for_cbor(&value)?;
-        self.set(
-            cid,
-            struct_to_cbor(&value)?, //bytes
-        );
-        Ok(cid)
-    }
-
-    pub(crate) fn set(&mut self, cid: Cid, bytes: Vec<u8>) -> () {
-        self.map.insert(cid.to_string(), Bytes(bytes));
-        ()
-    }
-
-    pub(crate) fn get(&self, cid: Cid) -> Option<&Vec<u8>> {
-        self.map.get(&cid.to_string()).map(|bytes| &bytes.0)
-    }
-    pub(crate) fn delete(&mut self, cid: Cid) -> Result<()> {
-        self.map.remove(&cid.to_string());
-        Ok(())
-    }
-
-    pub(crate) fn get_many(&mut self, cids: Vec<Cid>) -> Result<BlocksAndMissing> {
-        let mut missing: Vec<Cid> = Vec::new();
-        let mut blocks = BlockMap::new();
-        for cid in cids {
-            let got = self.map.get(&cid.to_string()).map(|bytes| &bytes.0);
-            if let Some(bytes) = got {
-                blocks.set(cid, bytes.clone());
-            } else {
-                missing.push(cid);
-            }
-        }
-        Ok(BlocksAndMissing { blocks, missing })
-    }
-
-    pub(crate) fn has(&self, cid: Cid) -> bool {
-        self.map.contains_key(&cid.to_string())
-    }
-
-    pub(crate) fn clear(&mut self) -> () {
-        self.map.clear()
-    }
-
-    // Not really using. Issues with closures
-    pub(crate) fn for_each(&self, cb: impl Fn(&Vec<u8>, Cid) -> ()) -> Result<()> {
-        for (key, val) in self.map.iter() {
-            cb(&val.0, Cid::from_str(&key)?);
-        }
-        Ok(())
-    }
-
-    pub(crate) fn entries(&self) -> Result<Vec<CidAndBytes>> {
-        let mut entries: Vec<CidAndBytes> = Vec::new();
-        for (cid, bytes) in self.map.iter() {
-            entries.push(CidAndBytes {
-                cid: Cid::from_str(cid)?,
-                bytes: bytes.0.clone(),
-            });
-        }
-        Ok(entries)
-    }
-
-    pub(crate) fn cids(&self) -> Result<Vec<Cid>> {
-        Ok(self.entries()?.into_iter().map(|e| e.cid).collect())
-    }
-
-    pub(crate) fn add_map(&mut self, to_add: BlockMap) -> Result<()> {
-        let results = for (cid, bytes) in to_add.map.iter() {
-            self.set(Cid::from_str(cid)?, bytes.0.clone());
-        };
-        Ok(results)
-    }
-
-    pub(crate) fn size(&self) -> usize {
-        self.map.len()
-    }
-
-    pub(crate) fn byte_size(&self) -> Result<usize> {
-        let mut size = 0;
-        for (_, bytes) in self.map.iter() {
-            size += bytes.0.len();
-        }
-        Ok(size)
-    }
-
-    pub(crate) fn equals(&self, other: BlockMap) -> Result<bool> {
-        if self.size() != other.size() {
-            return Ok(false);
-        }
-        for entry in self.entries()? {
-            let other_bytes = other.get(entry.cid);
-            if let Some(o) = other_bytes {
-                if &entry.bytes != o {
-                    return Ok(false);
-                }
-            } else {
-                return Ok(false);
-            }
-        }
-        Ok(true)
-    }
-}
-
-// Helper function for the iterator conversion.
-fn to_cid_and_bytes((cid_str, bytes): (String, Bytes)) -> CidAndBytes {
-    // We assume the key is always valid; otherwise, you could handle the error.
-    let cid = Cid::from_str(&cid_str).expect("BlockMap contains an invalid CID string");
-    CidAndBytes {
-        cid,
-        bytes: bytes.0,
-    }
-}
-
-impl IntoIterator for BlockMap {
-    type Item = CidAndBytes;
-    // Using the iterator returned by BTreeMap's into_iter, then mapping with a function pointer.
-    type IntoIter = std::iter::Map<
-        std::collections::btree_map::IntoIter<String, Bytes>,
-        fn((String, Bytes)) -> CidAndBytes,
-    >;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.map.into_iter().map(to_cid_and_bytes)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct BlocksAndMissing {
-    pub blocks: BlockMap,
-    pub missing: Vec<Cid>,
-}

src/repo/mod.rs

···
-pub(crate) mod block_map;
-pub(crate) mod storage;
-pub(crate) mod types;

src/repo/storage/mod.rs

···
-//! ReadableBlockstore for managing blocks in the repository.
-
-use crate::repo::block_map::{BlockMap, MissingBlockError};
-use crate::repo::util::{cbor_to_lex_record, parse_obj_by_def};
-use anyhow::{Context, Result};
-use atrium_repo::Cid;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-/// Trait for a readable blockstore.
-pub(crate) trait ReadableBlockstore {
-    /// Get the raw bytes for a given CID.
-    fn get_bytes(&self, cid: &Cid) -> Result<Option<Vec<u8>>>;
-
-    /// Check if a block exists for a given CID.
-    fn has(&self, cid: &Cid) -> Result<bool>;
-
-    /// Get multiple blocks for a list of CIDs.
-    fn get_blocks(&self, cids: &[Cid]) -> Result<(BlockMap, Vec<Cid>)>;
-
-    /// Attempt to read an object by CID and definition.
-    fn attempt_read<T>(&self, cid: &Cid, def: &str) -> Result<Option<(T, Vec<u8>)>>
-    where
-        T: serde::de::DeserializeOwned;
-
-    /// Read an object and its raw bytes by CID and definition.
-    fn read_obj_and_bytes<T>(&self, cid: &Cid, def: &str) -> Result<(T, Vec<u8>)>
-    where
-        T: serde::de::DeserializeOwned;
-
-    /// Read an object by CID and definition.
-    fn read_obj<T>(&self, cid: &Cid, def: &str) -> Result<T>
-    where
-        T: serde::de::DeserializeOwned;
-
-    /// Attempt to read a record by CID.
-    fn attempt_read_record(&self, cid: &Cid) -> Result<Option<RepoRecord>>;
-
-    /// Read a record by CID.
-    fn read_record(&self, cid: &Cid) -> Result<RepoRecord>;
-}
-
-/// Concrete implementation of the ReadableBlockstore.
-pub(crate) struct InMemoryBlockstore {
-    blocks: HashMap<Cid, Vec<u8>>,
-}
-
-impl InMemoryBlockstore {
-    /// Create a new in-memory blockstore.
-    pub fn new() -> Self {
-        Self {
-            blocks: HashMap::new(),
-        }
-    }
-
-    /// Add a block to the blockstore.
-    pub fn add_block(&mut self, cid: Cid, bytes: Vec<u8>) {
-        self.blocks.insert(cid, bytes);
-    }
-}
-
-impl ReadableBlockstore for InMemoryBlockstore {
-    fn get_bytes(&self, cid: &Cid) -> Result<Option<Vec<u8>>> {
-        Ok(self.blocks.get(cid).cloned())
-    }
-
-    fn has(&self, cid: &Cid) -> Result<bool> {
-        Ok(self.blocks.contains_key(cid))
-    }
-
-    fn get_blocks(&self, cids: &[Cid]) -> Result<(BlockMap, Vec<Cid>)> {
-        let mut blocks = BlockMap::new();
-        let mut missing = Vec::new();
-
-        for cid in cids {
-            if let Some(bytes) = self.blocks.get(cid) {
-                blocks.insert(*cid, bytes.clone());
-            } else {
-                missing.push(*cid);
-            }
-        }
-
-        Ok((blocks, missing))
-    }
-
-    fn attempt_read<T>(&self, cid: &Cid, def: &str) -> Result<Option<(T, Vec<u8>)>>
-    where
-        T: serde::de::DeserializeOwned,
-    {
-        if let Some(bytes) = self.get_bytes(cid)? {
-            let obj = parse_obj_by_def(&bytes, cid, def)?;
-            Ok(Some((obj, bytes)))
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn read_obj_and_bytes<T>(&self, cid: &Cid, def: &str) -> Result<(T, Vec<u8>)>
-    where
-        T: serde::de::DeserializeOwned,
-    {
-        if let Some((obj, bytes)) = self.attempt_read(cid, def)? {
-            Ok((obj, bytes))
-        } else {
-            Err(MissingBlockError::new(*cid, def).into())
-        }
-    }
-
-    fn read_obj<T>(&self, cid: &Cid, def: &str) -> Result<T>
-    where
-        T: serde::de::DeserializeOwned,
-    {
-        let (obj, _) = self.read_obj_and_bytes(cid, def)?;
-        Ok(obj)
-    }
-
-    fn attempt_read_record(&self, cid: &Cid) -> Result<Option<RepoRecord>> {
-        match self.read_record(cid) {
-            Ok(record) => Ok(Some(record)),
-            Err(_) => Ok(None),
-        }
-    }
-
-    fn read_record(&self, cid: &Cid) -> Result<RepoRecord> {
-        if let Some(bytes) = self.get_bytes(cid)? {
-            cbor_to_lex_record(&bytes)
-        } else {
-            Err(MissingBlockError::new(*cid, "RepoRecord").into())
-        }
-    }
-}

src/repo/types.rs

···
-//! Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/types.rs
-//! blacksky-algorithms/rsky is licensed under the Apache License 2.0
-//! Reimplemented here because of conflicting dependencies between atrium and rsky
-
-use crate::repo::block_map::{BlockMap, CidSet};
-use anyhow::{Result, bail};
-use atrium_api::types::BlobRef;
-use atrium_repo::Cid;
-use ipld_core::ipld::Ipld;
-use rsky_syntax::aturi::AtUri;
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use std::fmt;
-use std::fmt::Debug;
-
-// Repo nodes
-// ---------------
-
-// IMPORTANT: Ordering of these fields must not be changed
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct UnsignedCommit {
-    pub did: String,
-    pub rev: String,
-    pub data: Cid,
-    // `prev` added for backwards compatibility with v2, no requirement of keeping around history
-    pub prev: Option<Cid>,
-    pub version: u8, // Should be 3
-}
-
-// IMPORTANT: Ordering of these fields must not be changed
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct Commit {
-    pub did: String,
-    pub rev: String,
-    pub data: Cid,
-    pub prev: Option<Cid>,
-    pub version: u8, // Should be 3
-    #[serde(with = "serde_bytes")]
-    pub sig: Vec<u8>,
-}
-
-// IMPORTANT: Ordering of these fields must not be changed
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct LegacyV2Commit {
-    pub did: String,
-    pub rev: Option<String>,
-    pub data: Cid,
-    pub prev: Option<Cid>,
-    pub version: u8, // Should be 2
-    #[serde(with = "serde_bytes")]
-    pub sig: Vec<u8>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum VersionedCommit {
-    Commit(Commit),
-    LegacyV2Commit(LegacyV2Commit),
-}
-
-impl VersionedCommit {
-    pub fn data(&self) -> Cid {
-        match self {
-            VersionedCommit::Commit(c) => c.data,
-            VersionedCommit::LegacyV2Commit(c) => c.data,
-        }
-    }
-
-    pub fn did(&self) -> &String {
-        match self {
-            VersionedCommit::Commit(c) => &c.did,
-            VersionedCommit::LegacyV2Commit(c) => &c.did,
-        }
-    }
-
-    pub fn version(&self) -> u8 {
-        match self {
-            VersionedCommit::Commit(c) => c.version,
-            VersionedCommit::LegacyV2Commit(c) => c.version,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum Lex {
-    Ipld(Ipld),
-    Blob(BlobRef),
-    List(Vec<Lex>),
-    Map(BTreeMap<String, Lex>),
-}
-
-// Repo Operations
-// ---------------
-
-pub type RepoRecord = BTreeMap<String, Lex>;
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct BlobConstraint {
-    pub max_size: Option<usize>,
-    pub accept: Option<Vec<String>>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct PreparedBlobRef {
-    pub cid: Cid,
-    pub mime_type: String,
-    pub constraints: BlobConstraint,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct PreparedCreateOrUpdate {
-    pub action: WriteOpAction,
-    pub uri: String,
-    pub cid: Cid,
-    pub swap_cid: Option<Cid>,
-    pub record: RepoRecord,
-    pub blobs: Vec<PreparedBlobRef>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct PreparedDelete {
-    pub action: WriteOpAction,
-    pub uri: String,
-    pub swap_cid: Option<Cid>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum PreparedWrite {
-    Create(PreparedCreateOrUpdate),
-    Update(PreparedCreateOrUpdate),
-    Delete(PreparedDelete),
-}
-
-impl PreparedWrite {
-    pub fn uri(&self) -> &String {
-        match self {
-            PreparedWrite::Create(w) => &w.uri,
-            PreparedWrite::Update(w) => &w.uri,
-            PreparedWrite::Delete(w) => &w.uri,
-        }
-    }
-
-    pub fn cid(&self) -> Option<Cid> {
-        match self {
-            PreparedWrite::Create(w) => Some(w.cid),
-            PreparedWrite::Update(w) => Some(w.cid),
-            PreparedWrite::Delete(_) => None,
-        }
-    }
-
-    pub fn swap_cid(&self) -> &Option<Cid> {
-        match self {
-            PreparedWrite::Create(w) => &w.swap_cid,
-            PreparedWrite::Update(w) => &w.swap_cid,
-            PreparedWrite::Delete(w) => &w.swap_cid,
-        }
-    }
-
-    pub fn action(&self) -> &WriteOpAction {
-        match self {
-            PreparedWrite::Create(w) => &w.action,
-            PreparedWrite::Update(w) => &w.action,
-            PreparedWrite::Delete(w) => &w.action,
-        }
-    }
-
-    /// TEQ: Add blobs() impl
-    pub fn blobs(&self) -> Option<&Vec<PreparedBlobRef>> {
-        match self {
-            PreparedWrite::Create(w) => Some(&w.blobs),
-            PreparedWrite::Update(w) => Some(&w.blobs),
-            PreparedWrite::Delete(_) => None,
-        }
-    }
-}
-
-impl From<&PreparedWrite> for CommitAction {
-    fn from(value: &PreparedWrite) -> Self {
-        match value {
-            &PreparedWrite::Create(_) => CommitAction::Create,
-            &PreparedWrite::Update(_) => CommitAction::Update,
-            &PreparedWrite::Delete(_) => CommitAction::Delete,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum WriteOpAction {
-    Create,
-    Update,
-    Delete,
-}
-
-impl fmt::Display for WriteOpAction {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Match each variant and write its lowercase representation.
-        match self {
-            WriteOpAction::Create => write!(f, "create"),
-            WriteOpAction::Update => write!(f, "update"),
-            WriteOpAction::Delete => write!(f, "delete"),
-        }
-    }
-}
-
-impl From<WriteOpAction> for CommitAction {
-    fn from(value: WriteOpAction) -> Self {
-        match value {
-            WriteOpAction::Create => CommitAction::Create,
-            WriteOpAction::Update => CommitAction::Update,
-            WriteOpAction::Delete => CommitAction::Delete,
-        }
-    }
-}
-
-impl From<&WriteOpAction> for CommitAction {
-    fn from(value: &WriteOpAction) -> Self {
-        match value {
-            &WriteOpAction::Create => CommitAction::Create,
-            &WriteOpAction::Update => CommitAction::Update,
-            &WriteOpAction::Delete => CommitAction::Delete,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RecordCreateOrUpdateOp {
-    pub action: WriteOpAction,
-    pub collection: String,
-    pub rkey: String,
-    pub record: RepoRecord,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RecordDeleteOp {
-    pub action: WriteOpAction,
-    pub collection: String,
-    pub rkey: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum RecordWriteOp {
-    Create(RecordCreateOrUpdateOp),
-    Update(RecordCreateOrUpdateOp),
-    Delete(RecordDeleteOp),
-}
-
-impl RecordWriteOp {
-    pub fn collection(&self) -> String {
-        match self {
-            RecordWriteOp::Create(r) => r.collection.clone(),
-            RecordWriteOp::Update(r) => r.collection.clone(),
-            RecordWriteOp::Delete(r) => r.collection.clone(),
-        }
-    }
-
-    pub fn rkey(&self) -> String {
-        match self {
-            RecordWriteOp::Create(r) => r.rkey.clone(),
-            RecordWriteOp::Update(r) => r.rkey.clone(),
-            RecordWriteOp::Delete(r) => r.rkey.clone(),
-        }
-    }
-}
-
-pub fn create_write_to_op(write: PreparedCreateOrUpdate) -> Result<RecordWriteOp> {
-    let write_at_uri: AtUri = write.uri.try_into()?;
-    Ok(RecordWriteOp::Create {
-        0: RecordCreateOrUpdateOp {
-            action: WriteOpAction::Create,
-            collection: write_at_uri.get_collection(),
-            rkey: write_at_uri.get_rkey(),
-            record: write.record,
-        },
-    })
-}
-
-pub fn update_write_to_op(write: PreparedCreateOrUpdate) -> Result<RecordWriteOp> {
-    let write_at_uri: AtUri = write.uri.try_into()?;
-    Ok(RecordWriteOp::Update {
-        0: RecordCreateOrUpdateOp {
-            action: WriteOpAction::Update,
-            collection: write_at_uri.get_collection(),
-            rkey: write_at_uri.get_rkey(),
-            record: write.record,
-        },
-    })
-}
-
-pub fn delete_write_to_op(write: PreparedDelete) -> Result<RecordWriteOp> {
-    let write_at_uri: AtUri = write.uri.try_into()?;
-    Ok(RecordWriteOp::Delete {
-        0: RecordDeleteOp {
-            action: WriteOpAction::Delete,
-            collection: write_at_uri.get_collection(),
-            rkey: write_at_uri.get_rkey(),
-        },
-    })
-}
-
-pub fn write_to_op(write: PreparedWrite) -> Result<RecordWriteOp> {
-    match write {
-        PreparedWrite::Create(c) => create_write_to_op(c),
-        PreparedWrite::Update(u) => update_write_to_op(u),
-        PreparedWrite::Delete(d) => delete_write_to_op(d),
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum RecordWriteEnum {
-    List(Vec<RecordWriteOp>),
-    Single(RecordWriteOp),
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RecordCreateOrDeleteDescript {
-    pub action: WriteOpAction,
-    pub collection: String,
-    pub rkey: String,
-    pub cid: Cid,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RecordUpdateDescript {
-    pub action: WriteOpAction,
-    pub collection: String,
-    pub rkey: String,
-    pub prev: Cid,
-    pub cid: Cid,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum RecordWriteDescript {
-    Create(RecordCreateOrDeleteDescript),
-    Update(RecordUpdateDescript),
-    Delete(RecordCreateOrDeleteDescript),
-}
-
-impl RecordWriteDescript {
-    pub fn action(&self) -> String {
-        match self {
-            RecordWriteDescript::Create(r) => r.action.to_string(),
-            RecordWriteDescript::Update(r) => r.action.to_string(),
-            RecordWriteDescript::Delete(r) => r.action.to_string(),
-        }
-    }
-}
-
-pub type WriteLog = Vec<Vec<RecordWriteDescript>>;
-
-// Updates/Commits
-// ---------------
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct CommitData {
-    pub cid: Cid,
-    pub rev: String,
-    pub since: Option<String>,
-    pub prev: Option<Cid>,
-    pub new_blocks: BlockMap,
-    pub relevant_blocks: BlockMap,
-    pub removed_cids: CidSet,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum CommitAction {
-    Create,
-    Update,
-    Delete,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct CommitOp {
-    pub action: CommitAction,
-    pub path: String,
-    pub cid: Option<Cid>,
-    pub prev: Option<Cid>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct CommitDataWithOps {
-    #[serde(flatten)]
-    pub commit_data: CommitData,
-    pub ops: Vec<CommitOp>,
-    pub prev_data: Option<Cid>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct SyncEvtData {
-    pub cid: Cid,
-    pub rev: String,
-    pub blocks: BlockMap,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RepoUpdate {
-    pub cid: Cid,
-    pub rev: String,
-    pub since: Option<String>,
-    pub prev: Option<Cid>,
-    pub new_blocks: BlockMap,
-    pub removed_cids: CidSet,
-    pub ops: Vec<RecordWriteOp>,
-}
-
-pub type CollectionContents = BTreeMap<String, RepoRecord>;
-pub type RepoContents = BTreeMap<String, CollectionContents>;
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RepoRecordWithCid {
-    pub cid: Cid,
-    pub value: RepoRecord,
-}
-pub type CollectionContentsWithCids = BTreeMap<String, RepoRecordWithCid>;
-pub type RepoContentsWithCids = BTreeMap<String, CollectionContentsWithCids>;
-
-pub type DatastoreContents = BTreeMap<String, Cid>;
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RecordPath {
-    pub collection: String,
-    pub rkey: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct RecordClaim {
-    pub collection: String,
-    pub rkey: String,
-    pub record: Option<RepoRecord>,
-}
-
-// Sync
-// ---------------
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct VerifiedDiff {
-    pub writes: Vec<RecordWriteDescript>,
-    pub commit: CommitData,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct VerifiedRepo {
-    pub creates: Vec<RecordCreateOrDeleteDescript>,
-    pub commit: CommitData,
-}
-
-pub type CarBlock = CidAndBytes;
-
-pub struct CidAndBytes {
-    pub cid: Cid,
-    pub bytes: Vec<u8>,
-}
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum Ids {
-    ComAtprotoAdminDefs,
-    ComAtprotoAdminDeleteAccount,
-    ComAtprotoAdminDisableAccountInvites,
-    ComAtprotoAdminDisableInviteCodes,
-    ComAtprotoAdminEnableAccountInvites,
-    ComAtprotoAdminGetAccountInfo,
-    ComAtprotoAdminGetAccountInfos,
-    ComAtprotoAdminGetInviteCodes,
-    ComAtprotoAdminGetSubjectStatus,
-    ComAtprotoAdminSendEmail,
-    ComAtprotoAdminUpdateAccountEmail,
-    ComAtprotoAdminUpdateAccountHandle,
-    ComAtprotoAdminUpdateAccountPassword,
-    ComAtprotoAdminUpdateSubjectStatus,
-    ComAtprotoIdentityGetRecommendedDidCredentials,
-    ComAtprotoIdentityRequestPlcOperationSignature,
-    ComAtprotoIdentityResolveHandle,
-    ComAtprotoIdentitySignPlcOperation,
-    ComAtprotoIdentitySubmitPlcOperation,
-    ComAtprotoIdentityUpdateHandle,
-    ComAtprotoLabelDefs,
-    ComAtprotoLabelQueryLabels,
-    ComAtprotoLabelSubscribeLabels,
-    ComAtprotoModerationCreateReport,
-    ComAtprotoModerationDefs,
-    ComAtprotoRepoApplyWrites,
-    ComAtprotoRepoCreateRecord,
-    ComAtprotoRepoDeleteRecord,
-    ComAtprotoRepoDescribeRepo,
-    ComAtprotoRepoGetRecord,
-    ComAtprotoRepoImportRepo,
-    ComAtprotoRepoListMissingBlobs,
-    ComAtprotoRepoListRecords,
-    ComAtprotoRepoPutRecord,
-    ComAtprotoRepoStrongRef,
-    ComAtprotoRepoUploadBlob,
-    ComAtprotoServerActivateAccount,
-    ComAtprotoServerCheckAccountStatus,
-    ComAtprotoServerConfirmEmail,
-    ComAtprotoServerCreateAccount,
-    ComAtprotoServerCreateAppPassword,
-    ComAtprotoServerCreateInviteCode,
-    ComAtprotoServerCreateInviteCodes,
-    ComAtprotoServerCreateSession,
-    ComAtprotoServerDeactivateAccount,
-    ComAtprotoServerDefs,
-    ComAtprotoServerDeleteAccount,
-    ComAtprotoServerDeleteSession,
-    ComAtprotoServerDescribeServer,
-    ComAtprotoServerGetAccountInviteCodes,
-    ComAtprotoServerGetServiceAuth,
-    ComAtprotoServerGetSession,
-    ComAtprotoServerListAppPasswords,
-    ComAtprotoServerRefreshSession,
-    ComAtprotoServerRequestAccountDelete,
-    ComAtprotoServerRequestEmailConfirmation,
-    ComAtprotoServerRequestEmailUpdate,
-    ComAtprotoServerRequestPasswordReset,
-    ComAtprotoServerReserveSigningKey,
-    ComAtprotoServerResetPassword,
-    ComAtprotoServerRevokeAppPassword,
-    ComAtprotoServerUpdateEmail,
-    ComAtprotoSyncGetBlob,
-    ComAtprotoSyncGetBlocks,
-    ComAtprotoSyncGetCheckout,
-    ComAtprotoSyncGetHead,
-    ComAtprotoSyncGetLatestCommit,
-    ComAtprotoSyncGetRecord,
-    ComAtprotoSyncGetRepo,
-    ComAtprotoSyncListBlobs,
-    ComAtprotoSyncListRepos,
-    ComAtprotoSyncNotifyOfUpdate,
-    ComAtprotoSyncRequestCrawl,
-    ComAtprotoSyncSubscribeRepos,
-    ComAtprotoTempCheckSignupQueue,
-    ComAtprotoTempFetchLabels,
-    ComAtprotoTempRequestPhoneVerification,
-    AppBskyActorDefs,
-    AppBskyActorGetPreferences,
-    AppBskyActorGetProfile,
-    AppBskyActorGetProfiles,
-    AppBskyActorGetSuggestions,
-    AppBskyActorProfile,
-    AppBskyActorPutPreferences,
-    AppBskyActorSearchActors,
-    AppBskyActorSearchActorsTypeahead,
-    AppBskyEmbedExternal,
-    AppBskyEmbedImages,
-    AppBskyEmbedRecord,
-    AppBskyEmbedRecordWithMedia,
-    AppBskyFeedDefs,
-    AppBskyFeedDescribeFeedGenerator,
-    AppBskyFeedGenerator,
-    AppBskyFeedGetActorFeeds,
-    AppBskyFeedGetActorLikes,
-    AppBskyFeedGetAuthorFeed,
-    AppBskyFeedGetFeed,
-    AppBskyFeedGetFeedGenerator,
-    AppBskyFeedGetFeedGenerators,
-    AppBskyFeedGetFeedSkeleton,
-    AppBskyFeedGetLikes,
-    AppBskyFeedGetListFeed,
-    AppBskyFeedGetPostThread,
-    AppBskyFeedGetPosts,
-    AppBskyFeedGetRepostedBy,
-    AppBskyFeedGetSuggestedFeeds,
-    AppBskyFeedGetTimeline,
-    AppBskyFeedLike,
-    AppBskyFeedPost,
-    AppBskyFeedRepost,
-    AppBskyFeedSearchPosts,
-    AppBskyFeedThreadgate,
-    AppBskyGraphBlock,
-    AppBskyGraphDefs,
-    AppBskyGraphFollow,
-    AppBskyGraphGetBlocks,
-    AppBskyGraphGetFollowers,
-    AppBskyGraphGetFollows,
-    AppBskyGraphGetList,
-    AppBskyGraphGetListBlocks,
-    AppBskyGraphGetListMutes,
-    AppBskyGraphGetLists,
-    AppBskyGraphGetMutes,
-    AppBskyGraphGetRelationships,
-    AppBskyGraphGetSuggestedFollowsByActor,
-    AppBskyGraphList,
-    AppBskyGraphListblock,
-    AppBskyGraphListitem,
-    AppBskyGraphMuteActor,
-    AppBskyGraphMuteActorList,
-    AppBskyGraphUnmuteActor,
-    AppBskyGraphUnmuteActorList,
-    AppBskyLabelerDefs,
-    AppBskyLabelerGetServices,
-    AppBskyLabelerService,
-    AppBskyNotificationGetUnreadCount,
-    AppBskyNotificationListNotifications,
-    AppBskyNotificationRegisterPush,
-    AppBskyNotificationUpdateSeen,
-    AppBskyRichtextFacet,
-    AppBskyUnspeccedDefs,
-    AppBskyUnspeccedGetPopularFeedGenerators,
-    AppBskyUnspeccedGetTaggedSuggestions,
-    AppBskyUnspeccedSearchActorsSkeleton,
-    AppBskyUnspeccedSearchPostsSkeleton,
-    ToolsOzoneCommunicationCreateTemplate,
-    ToolsOzoneCommunicationDefs,
-    ToolsOzoneCommunicationDeleteTemplate,
-    ToolsOzoneCommunicationListTemplates,
-    ToolsOzoneCommunicationUpdateTemplate,
-    ToolsOzoneModerationDefs,
-    ToolsOzoneModerationEmitEvent,
-    ToolsOzoneModerationGetEvent,
-    ToolsOzoneModerationGetRecord,
-    ToolsOzoneModerationGetRepo,
-    ToolsOzoneModerationQueryEvents,
-    ToolsOzoneModerationQueryStatuses,
-    ToolsOzoneModerationSearchRepos,
-    ToolsOzoneServerGetConfig,
-    ToolsOzoneTeamAddMember,
-    ToolsOzoneTeamDefs,
-    ToolsOzoneTeamDeleteMember,
-    ToolsOzoneTeamListMembers,
-    ToolsOzoneTeamUpdateMember,
-    ChatBskyActorDeleteAccount,
-    ChatBskyActorExportAccountData,
-    ChatBskyConvoDeleteMessageForSelf,
-    ChatBskyConvoGetConvo,
-    ChatBskyConvoGetConvoForMembers,
-    ChatBskyConvoGetLog,
-    ChatBskyConvoGetMessages,
-    ChatBskyConvoLeaveConvo,
-    ChatBskyConvoListConvos,
-    ChatBskyConvoMuteConvo,
-    ChatBskyConvoSendMessage,
-    ChatBskyConvoSendMessageBatch,
-    ChatBskyConvoUnmuteConvo,
-    ChatBskyConvoUpdateRead,
-}
-
-impl Ids {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Ids::ComAtprotoAdminDefs => "com.atproto.admin.defs",
-            Ids::ComAtprotoAdminDeleteAccount => "com.atproto.admin.deleteAccount",
-            Ids::ComAtprotoAdminDisableAccountInvites => "com.atproto.admin.disableAccountInvites",
-            Ids::ComAtprotoAdminDisableInviteCodes => "com.atproto.admin.disableInviteCodes",
-            Ids::ComAtprotoAdminEnableAccountInvites => "com.atproto.admin.enableAccountInvites",
-            Ids::ComAtprotoAdminGetAccountInfo => "com.atproto.admin.getAccountInfo",
-            Ids::ComAtprotoAdminGetAccountInfos => "com.atproto.admin.getAccountInfos",
-            Ids::ComAtprotoAdminGetInviteCodes => "com.atproto.admin.getInviteCodes",
-            Ids::ComAtprotoAdminGetSubjectStatus => "com.atproto.admin.getSubjectStatus",
-            Ids::ComAtprotoAdminSendEmail => "com.atproto.admin.sendEmail",
-            Ids::ComAtprotoAdminUpdateAccountEmail => "com.atproto.admin.updateAccountEmail",
-            Ids::ComAtprotoAdminUpdateAccountHandle => "com.atproto.admin.updateAccountHandle",
-            Ids::ComAtprotoAdminUpdateAccountPassword => "com.atproto.admin.updateAccountPassword",
-            Ids::ComAtprotoAdminUpdateSubjectStatus => "com.atproto.admin.updateSubjectStatus",
-            Ids::ComAtprotoIdentityGetRecommendedDidCredentials => {
-                "com.atproto.identity.getRecommendedDidCredentials"
-            }
-            Ids::ComAtprotoIdentityRequestPlcOperationSignature => {
-                "com.atproto.identity.requestPlcOperationSignature"
-            }
-            Ids::ComAtprotoIdentityResolveHandle => "com.atproto.identity.resolveHandle",
-            Ids::ComAtprotoIdentitySignPlcOperation => "com.atproto.identity.signPlcOperation",
-            Ids::ComAtprotoIdentitySubmitPlcOperation => "com.atproto.identity.submitPlcOperation",
-            Ids::ComAtprotoIdentityUpdateHandle => "com.atproto.identity.updateHandle",
-            Ids::ComAtprotoLabelDefs => "com.atproto.label.defs",
-            Ids::ComAtprotoLabelQueryLabels => "com.atproto.label.queryLabels",
-            Ids::ComAtprotoLabelSubscribeLabels => "com.atproto.label.subscribeLabels",
-            Ids::ComAtprotoModerationCreateReport => "com.atproto.moderation.createReport",
-            Ids::ComAtprotoModerationDefs => "com.atproto.moderation.defs",
-            Ids::ComAtprotoRepoApplyWrites => "com.atproto.repo.applyWrites",
-            Ids::ComAtprotoRepoCreateRecord => "com.atproto.repo.createRecord",
-            Ids::ComAtprotoRepoDeleteRecord => "com.atproto.repo.deleteRecord",
-            Ids::ComAtprotoRepoDescribeRepo => "com.atproto.repo.describeRepo",
-            Ids::ComAtprotoRepoGetRecord => "com.atproto.repo.getRecord",
-            Ids::ComAtprotoRepoImportRepo => "com.atproto.repo.importRepo",
-            Ids::ComAtprotoRepoListMissingBlobs => "com.atproto.repo.listMissingBlobs",
-            Ids::ComAtprotoRepoListRecords => "com.atproto.repo.listRecords",
-            Ids::ComAtprotoRepoPutRecord => "com.atproto.repo.putRecord",
-            Ids::ComAtprotoRepoStrongRef => "com.atproto.repo.strongRef",
-            Ids::ComAtprotoRepoUploadBlob => "com.atproto.repo.uploadBlob",
-            Ids::ComAtprotoServerActivateAccount => "com.atproto.server.activateAccount",
-            Ids::ComAtprotoServerCheckAccountStatus => "com.atproto.server.checkAccountStatus",
-            Ids::ComAtprotoServerConfirmEmail => "com.atproto.server.confirmEmail",
-            Ids::ComAtprotoServerCreateAccount => "com.atproto.server.createAccount",
-            Ids::ComAtprotoServerCreateAppPassword => "com.atproto.server.createAppPassword",
-            Ids::ComAtprotoServerCreateInviteCode => "com.atproto.server.createInviteCode",
-            Ids::ComAtprotoServerCreateInviteCodes => "com.atproto.server.createInviteCodes",
-            Ids::ComAtprotoServerCreateSession => "com.atproto.server.createSession",
-            Ids::ComAtprotoServerDeactivateAccount => "com.atproto.server.deactivateAccount",
-            Ids::ComAtprotoServerDefs => "com.atproto.server.defs",
-            Ids::ComAtprotoServerDeleteAccount => "com.atproto.server.deleteAccount",
-            Ids::ComAtprotoServerDeleteSession => "com.atproto.server.deleteSession",
-            Ids::ComAtprotoServerDescribeServer => "com.atproto.server.describeServer",
-            Ids::ComAtprotoServerGetAccountInviteCodes => {
-                "com.atproto.server.getAccountInviteCodes"
-            }
-            Ids::ComAtprotoServerGetServiceAuth => "com.atproto.server.getServiceAuth",
-            Ids::ComAtprotoServerGetSession => "com.atproto.server.getSession",
-            Ids::ComAtprotoServerListAppPasswords => "com.atproto.server.listAppPasswords",
-            Ids::ComAtprotoServerRefreshSession => "com.atproto.server.refreshSession",
-            Ids::ComAtprotoServerRequestAccountDelete => "com.atproto.server.requestAccountDelete",
-            Ids::ComAtprotoServerRequestEmailConfirmation => {
-                "com.atproto.server.requestEmailConfirmation"
-            }
-            Ids::ComAtprotoServerRequestEmailUpdate => "com.atproto.server.requestEmailUpdate",
-            Ids::ComAtprotoServerRequestPasswordReset => "com.atproto.server.requestPasswordReset",
-            Ids::ComAtprotoServerReserveSigningKey => "com.atproto.server.reserveSigningKey",
-            Ids::ComAtprotoServerResetPassword => "com.atproto.server.resetPassword",
-            Ids::ComAtprotoServerRevokeAppPassword => "com.atproto.server.revokeAppPassword",
-            Ids::ComAtprotoServerUpdateEmail => "com.atproto.server.updateEmail",
-            Ids::ComAtprotoSyncGetBlob => "com.atproto.sync.getBlob",
-            Ids::ComAtprotoSyncGetBlocks => "com.atproto.sync.getBlocks",
-            Ids::ComAtprotoSyncGetCheckout => "com.atproto.sync.getCheckout",
-            Ids::ComAtprotoSyncGetHead => "com.atproto.sync.getHead",
-            Ids::ComAtprotoSyncGetLatestCommit => "com.atproto.sync.getLatestCommit",
-            Ids::ComAtprotoSyncGetRecord => "com.atproto.sync.getRecord",
-            Ids::ComAtprotoSyncGetRepo => "com.atproto.sync.getRepo",
-            Ids::ComAtprotoSyncListBlobs => "com.atproto.sync.listBlobs",
-            Ids::ComAtprotoSyncListRepos => "com.atproto.sync.listRepos",
-            Ids::ComAtprotoSyncNotifyOfUpdate => "com.atproto.sync.notifyOfUpdate",
-            Ids::ComAtprotoSyncRequestCrawl => "com.atproto.sync.requestCrawl",
-            Ids::ComAtprotoSyncSubscribeRepos => "com.atproto.sync.subscribeRepos",
-            Ids::ComAtprotoTempCheckSignupQueue => "com.atproto.temp.checkSignupQueue",
-            Ids::ComAtprotoTempFetchLabels => "com.atproto.temp.fetchLabels",
-            Ids::ComAtprotoTempRequestPhoneVerification => {
-                "com.atproto.temp.requestPhoneVerification"
-            }
-            Ids::AppBskyActorDefs => "app.bsky.actor.defs",
-            Ids::AppBskyActorGetPreferences => "app.bsky.actor.getPreferences",
-            Ids::AppBskyActorGetProfile => "app.bsky.actor.getProfile",
-            Ids::AppBskyActorGetProfiles => "app.bsky.actor.getProfiles",
-            Ids::AppBskyActorGetSuggestions => "app.bsky.actor.getSuggestions",
-            Ids::AppBskyActorProfile => "app.bsky.actor.profile",
-            Ids::AppBskyActorPutPreferences => "app.bsky.actor.putPreferences",
-            Ids::AppBskyActorSearchActors => "app.bsky.actor.searchActors",
-            Ids::AppBskyActorSearchActorsTypeahead => "app.bsky.actor.searchActorsTypeahead",
-            Ids::AppBskyEmbedExternal => "app.bsky.embed.external",
-            Ids::AppBskyEmbedImages => "app.bsky.embed.images",
-            Ids::AppBskyEmbedRecord => "app.bsky.embed.record",
-            Ids::AppBskyEmbedRecordWithMedia => "app.bsky.embed.recordWithMedia",
-            Ids::AppBskyFeedDefs => "app.bsky.feed.defs",
-            Ids::AppBskyFeedDescribeFeedGenerator => "app.bsky.feed.describeFeedGenerator",
-            Ids::AppBskyFeedGenerator => "app.bsky.feed.generator",
-            Ids::AppBskyFeedGetActorFeeds => "app.bsky.feed.getActorFeeds",
-            Ids::AppBskyFeedGetActorLikes => "app.bsky.feed.getActorLikes",
-            Ids::AppBskyFeedGetAuthorFeed => "app.bsky.feed.getAuthorFeed",
-            Ids::AppBskyFeedGetFeed => "app.bsky.feed.getFeed",
-            Ids::AppBskyFeedGetFeedGenerator => "app.bsky.feed.getFeedGenerator",
-            Ids::AppBskyFeedGetFeedGenerators => "app.bsky.feed.getFeedGenerators",
-            Ids::AppBskyFeedGetFeedSkeleton => "app.bsky.feed.getFeedSkeleton",
-            Ids::AppBskyFeedGetLikes => "app.bsky.feed.getLikes",
-            Ids::AppBskyFeedGetListFeed => "app.bsky.feed.getListFeed",
-            Ids::AppBskyFeedGetPostThread => "app.bsky.feed.getPostThread",
-            Ids::AppBskyFeedGetPosts => "app.bsky.feed.getPosts",
-            Ids::AppBskyFeedGetRepostedBy => "app.bsky.feed.getRepostedBy",
-            Ids::AppBskyFeedGetSuggestedFeeds => "app.bsky.feed.getSuggestedFeeds",
-            Ids::AppBskyFeedGetTimeline => "app.bsky.feed.getTimeline",
-            Ids::AppBskyFeedLike => "app.bsky.feed.like",
-            Ids::AppBskyFeedPost => "app.bsky.feed.post",
-            Ids::AppBskyFeedRepost => "app.bsky.feed.repost",
-            Ids::AppBskyFeedSearchPosts => "app.bsky.feed.searchPosts",
-            Ids::AppBskyFeedThreadgate => "app.bsky.feed.threadgate",
-            Ids::AppBskyGraphBlock => "app.bsky.graph.block",
-            Ids::AppBskyGraphDefs => "app.bsky.graph.defs",
-            Ids::AppBskyGraphFollow => "app.bsky.graph.follow",
-            Ids::AppBskyGraphGetBlocks => "app.bsky.graph.getBlocks",
-            Ids::AppBskyGraphGetFollowers => "app.bsky.graph.getFollowers",
-            Ids::AppBskyGraphGetFollows => "app.bsky.graph.getFollows",
-            Ids::AppBskyGraphGetList => "app.bsky.graph.getList",
-            Ids::AppBskyGraphGetListBlocks => "app.bsky.graph.getListBlocks",
-            Ids::AppBskyGraphGetListMutes => "app.bsky.graph.getListMutes",
-            Ids::AppBskyGraphGetLists => "app.bsky.graph.getLists",
-            Ids::AppBskyGraphGetMutes => "app.bsky.graph.getMutes",
-            Ids::AppBskyGraphGetRelationships => "app.bsky.graph.getRelationships",
-            Ids::AppBskyGraphGetSuggestedFollowsByActor => {
-                "app.bsky.graph.getSuggestedFollowsByActor"
-            }
-            Ids::AppBskyGraphList => "app.bsky.graph.list",
-            Ids::AppBskyGraphListblock => "app.bsky.graph.listblock",
-            Ids::AppBskyGraphListitem => "app.bsky.graph.listitem",
-            Ids::AppBskyGraphMuteActor => "app.bsky.graph.muteActor",
-            Ids::AppBskyGraphMuteActorList => "app.bsky.graph.muteActorList",
-            Ids::AppBskyGraphUnmuteActor => "app.bsky.graph.unmuteActor",
-            Ids::AppBskyGraphUnmuteActorList => "app.bsky.graph.unmuteActorList",
-            Ids::AppBskyLabelerDefs => "app.bsky.labeler.defs",
-            Ids::AppBskyLabelerGetServices => "app.bsky.labeler.getServices",
-            Ids::AppBskyLabelerService => "app.bsky.labeler.service",
-            Ids::AppBskyNotificationGetUnreadCount => "app.bsky.notification.getUnreadCount",
-            Ids::AppBskyNotificationListNotifications => "app.bsky.notification.listNotifications",
-            Ids::AppBskyNotificationRegisterPush => "app.bsky.notification.registerPush",
-            Ids::AppBskyNotificationUpdateSeen => "app.bsky.notification.updateSeen",
-            Ids::AppBskyRichtextFacet => "app.bsky.richtext.facet",
-            Ids::AppBskyUnspeccedDefs => "app.bsky.unspecced.defs",
-            Ids::AppBskyUnspeccedGetPopularFeedGenerators => {
-                "app.bsky.unspecced.getPopularFeedGenerators"
-            }
-            Ids::AppBskyUnspeccedGetTaggedSuggestions => "app.bsky.unspecced.getTaggedSuggestions",
-            Ids::AppBskyUnspeccedSearchActorsSkeleton => "app.bsky.unspecced.searchActorsSkeleton",
-            Ids::AppBskyUnspeccedSearchPostsSkeleton => "app.bsky.unspecced.searchPostsSkeleton",
-            Ids::ToolsOzoneCommunicationCreateTemplate => {
-                "tools.ozone.communication.createTemplate"
-            }
-            Ids::ToolsOzoneCommunicationDefs => "tools.ozone.communication.defs",
-            Ids::ToolsOzoneCommunicationDeleteTemplate => {
-                "tools.ozone.communication.deleteTemplate"
-            }
-            Ids::ToolsOzoneCommunicationListTemplates => "tools.ozone.communication.listTemplates",
-            Ids::ToolsOzoneCommunicationUpdateTemplate => {
-                "tools.ozone.communication.updateTemplate"
-            }
-            Ids::ToolsOzoneModerationDefs => "tools.ozone.moderation.defs",
-            Ids::ToolsOzoneModerationEmitEvent => "tools.ozone.moderation.emitEvent",
-            Ids::ToolsOzoneModerationGetEvent => "tools.ozone.moderation.getEvent",
-            Ids::ToolsOzoneModerationGetRecord => "tools.ozone.moderation.getRecord",
-            Ids::ToolsOzoneModerationGetRepo => "tools.ozone.moderation.getRepo",
-            Ids::ToolsOzoneModerationQueryEvents => "tools.ozone.moderation.queryEvents",
-            Ids::ToolsOzoneModerationQueryStatuses => "tools.ozone.moderation.queryStatuses",
-            Ids::ToolsOzoneModerationSearchRepos => "tools.ozone.moderation.searchRepos",
-            Ids::ToolsOzoneServerGetConfig => "tools.ozone.server.getConfig",
-            Ids::ToolsOzoneTeamAddMember => "tools.ozone.team.addMember",
-            Ids::ToolsOzoneTeamDefs => "tools.ozone.team.defs",
-            Ids::ToolsOzoneTeamDeleteMember => "tools.ozone.team.deleteMember",
-            Ids::ToolsOzoneTeamListMembers => "tools.ozone.team.listMembers",
-            Ids::ToolsOzoneTeamUpdateMember => "tools.ozone.team.updateMember",
-            Ids::ChatBskyActorDeleteAccount => "chat.bsky.actor.deleteAccount",
-            Ids::ChatBskyActorExportAccountData => "chat.bsky.actor.exportAccountData",
-            Ids::ChatBskyConvoDeleteMessageForSelf => "chat.bsky.convo.deleteMessageForSelf",
-            Ids::ChatBskyConvoGetConvo => "chat.bsky.convo.getConvo",
-            Ids::ChatBskyConvoGetConvoForMembers => "chat.bsky.convo.getConvoForMembers",
-            Ids::ChatBskyConvoGetLog => "chat.bsky.convo.getLog",
-            Ids::ChatBskyConvoGetMessages => "chat.bsky.convo.getMessages",
-            Ids::ChatBskyConvoLeaveConvo => "chat.bsky.convo.leaveConvo",
-            Ids::ChatBskyConvoListConvos => "chat.bsky.convo.listConvos",
-            Ids::ChatBskyConvoMuteConvo => "chat.bsky.convo.muteConvo",
-            Ids::ChatBskyConvoSendMessage => "chat.bsky.convo.sendMessage",
-            Ids::ChatBskyConvoSendMessageBatch => "chat.bsky.convo.sendMessageBatch",
-            Ids::ChatBskyConvoUnmuteConvo => "chat.bsky.convo.unmuteConvo",
-            Ids::ChatBskyConvoUpdateRead => "chat.bsky.convo.updateRead",
-        }
-    }
-
-    pub fn from_str(s: &str) -> Result<Self> {
-        match s {
-            "com.atproto.admin.defs" => Ok(Ids::ComAtprotoAdminDefs),
-            "com.atproto.admin.deleteAccount" => Ok(Ids::ComAtprotoAdminDeleteAccount),
-            "com.atproto.admin.disableAccountInvites" => {
-                Ok(Ids::ComAtprotoAdminDisableAccountInvites)
-            }
-            "com.atproto.admin.disableInviteCodes" => Ok(Ids::ComAtprotoAdminDisableInviteCodes),
-            "com.atproto.admin.enableAccountInvites" => {
-                Ok(Ids::ComAtprotoAdminEnableAccountInvites)
-            }
-            "com.atproto.admin.getAccountInfo" => Ok(Ids::ComAtprotoAdminGetAccountInfo),
-            "com.atproto.admin.getAccountInfos" => Ok(Ids::ComAtprotoAdminGetAccountInfos),
-            "com.atproto.admin.getInviteCodes" => Ok(Ids::ComAtprotoAdminGetInviteCodes),
-            "com.atproto.admin.getSubjectStatus" => Ok(Ids::ComAtprotoAdminGetSubjectStatus),
-            "com.atproto.admin.sendEmail" => Ok(Ids::ComAtprotoAdminSendEmail),
-            "com.atproto.admin.updateAccountEmail" => Ok(Ids::ComAtprotoAdminUpdateAccountEmail),
-            "com.atproto.admin.updateAccountHandle" => Ok(Ids::ComAtprotoAdminUpdateAccountHandle),
-            "com.atproto.admin.updateAccountPassword" => {
-                Ok(Ids::ComAtprotoAdminUpdateAccountPassword)
-            }
-            "com.atproto.admin.updateSubjectStatus" => Ok(Ids::ComAtprotoAdminUpdateSubjectStatus),
-            "com.atproto.identity.getRecommendedDidCredentials" => {
-                Ok(Ids::ComAtprotoIdentityGetRecommendedDidCredentials)
-            }
-            "com.atproto.identity.requestPlcOperationSignature" => {
-                Ok(Ids::ComAtprotoIdentityRequestPlcOperationSignature)
-            }
-            "com.atproto.identity.resolveHandle" => Ok(Ids::ComAtprotoIdentityResolveHandle),
-            "com.atproto.identity.signPlcOperation" => Ok(Ids::ComAtprotoIdentitySignPlcOperation),
-            "com.atproto.identity.submitPlcOperation" => {
-                Ok(Ids::ComAtprotoIdentitySubmitPlcOperation)
-            }
-            "com.atproto.identity.updateHandle" => Ok(Ids::ComAtprotoIdentityUpdateHandle),
-            "com.atproto.label.defs" => Ok(Ids::ComAtprotoLabelDefs),
-            "com.atproto.label.queryLabels" => Ok(Ids::ComAtprotoLabelQueryLabels),
-            "com.atproto.label.subscribeLabels" => Ok(Ids::ComAtprotoLabelSubscribeLabels),
-            "com.atproto.moderation.createReport" => Ok(Ids::ComAtprotoModerationCreateReport),
-            "com.atproto.moderation.defs" => Ok(Ids::ComAtprotoModerationDefs),
-            "com.atproto.repo.applyWrites" => Ok(Ids::ComAtprotoRepoApplyWrites),
-            "com.atproto.repo.createRecord" => Ok(Ids::ComAtprotoRepoCreateRecord),
-            "com.atproto.repo.deleteRecord" => Ok(Ids::ComAtprotoRepoDeleteRecord),
-            "com.atproto.repo.describeRepo" => Ok(Ids::ComAtprotoRepoDescribeRepo),
-            "com.atproto.repo.getRecord" => Ok(Ids::ComAtprotoRepoGetRecord),
-            "com.atproto.repo.importRepo" => Ok(Ids::ComAtprotoRepoImportRepo),
-            "com.atproto.repo.listMissingBlobs" => Ok(Ids::ComAtprotoRepoListMissingBlobs),
-            "com.atproto.repo.listRecords" => Ok(Ids::ComAtprotoRepoListRecords),
-            "com.atproto.repo.putRecord" => Ok(Ids::ComAtprotoRepoPutRecord),
-            "com.atproto.repo.strongRef" => Ok(Ids::ComAtprotoRepoStrongRef),
-            "com.atproto.repo.uploadBlob" => Ok(Ids::ComAtprotoRepoUploadBlob),
-            "com.atproto.server.activateAccount" => Ok(Ids::ComAtprotoServerActivateAccount),
-            "com.atproto.server.checkAccountStatus" => Ok(Ids::ComAtprotoServerCheckAccountStatus),
-            "com.atproto.server.confirmEmail" => Ok(Ids::ComAtprotoServerConfirmEmail),
-            "com.atproto.server.createAccount" => Ok(Ids::ComAtprotoServerCreateAccount),
-            "com.atproto.server.createAppPassword" => Ok(Ids::ComAtprotoServerCreateAppPassword),
-            "com.atproto.server.createInviteCode" => Ok(Ids::ComAtprotoServerCreateInviteCode),
-            "com.atproto.server.createInviteCodes" => Ok(Ids::ComAtprotoServerCreateInviteCodes),
-            "com.atproto.server.createSession" => Ok(Ids::ComAtprotoServerCreateSession),
-            "com.atproto.server.deactivateAccount" => Ok(Ids::ComAtprotoServerDeactivateAccount),
-            "com.atproto.server.defs" => Ok(Ids::ComAtprotoServerDefs),
-            "com.atproto.server.deleteAccount" => Ok(Ids::ComAtprotoServerDeleteAccount),
-            "com.atproto.server.deleteSession" => Ok(Ids::ComAtprotoServerDeleteSession),
-            "com.atproto.server.describeServer" => Ok(Ids::ComAtprotoServerDescribeServer),
-            "com.atproto.server.getAccountInviteCodes" => {
-                Ok(Ids::ComAtprotoServerGetAccountInviteCodes)
-            }
-            "com.atproto.server.getServiceAuth" => Ok(Ids::ComAtprotoServerGetServiceAuth),
-            "com.atproto.server.getSession" => Ok(Ids::ComAtprotoServerGetSession),
-            "com.atproto.server.listAppPasswords" => Ok(Ids::ComAtprotoServerListAppPasswords),
-            "com.atproto.server.refreshSession" => Ok(Ids::ComAtprotoServerRefreshSession),
-            "com.atproto.server.requestAccountDelete" => {
-                Ok(Ids::ComAtprotoServerRequestAccountDelete)
-            }
-            "com.atproto.server.requestEmailConfirmation" => {
-                Ok(Ids::ComAtprotoServerRequestEmailConfirmation)
-            }
-            "com.atproto.server.requestEmailUpdate" => Ok(Ids::ComAtprotoServerRequestEmailUpdate),
-            "com.atproto.server.requestPasswordReset" => {
-                Ok(Ids::ComAtprotoServerRequestPasswordReset)
-            }
-            "com.atproto.server.reserveSigningKey" => Ok(Ids::ComAtprotoServerReserveSigningKey),
-            "com.atproto.server.resetPassword" => Ok(Ids::ComAtprotoServerResetPassword),
-            "com.atproto.server.revokeAppPassword" => Ok(Ids::ComAtprotoServerRevokeAppPassword),
-            "com.atproto.server.updateEmail" => Ok(Ids::ComAtprotoServerUpdateEmail),
-            "com.atproto.sync.getBlob" => Ok(Ids::ComAtprotoSyncGetBlob),
-            "com.atproto.sync.getBlocks" => Ok(Ids::ComAtprotoSyncGetBlocks),
-            "com.atproto.sync.getCheckout" => Ok(Ids::ComAtprotoSyncGetCheckout),
-            "com.atproto.sync.getHead" => Ok(Ids::ComAtprotoSyncGetHead),
-            "com.atproto.sync.getLatestCommit" => Ok(Ids::ComAtprotoSyncGetLatestCommit),
-            "com.atproto.sync.getRecord" => Ok(Ids::ComAtprotoSyncGetRecord),
-            "com.atproto.sync.getRepo" => Ok(Ids::ComAtprotoSyncGetRepo),
-            "com.atproto.sync.listBlobs" => Ok(Ids::ComAtprotoSyncListBlobs),
-            "com.atproto.sync.listRepos" => Ok(Ids::ComAtprotoSyncListRepos),
-            "com.atproto.sync.notifyOfUpdate" => Ok(Ids::ComAtprotoSyncNotifyOfUpdate),
-            "com.atproto.sync.requestCrawl" => Ok(Ids::ComAtprotoSyncRequestCrawl),
-            "com.atproto.sync.subscribeRepos" => Ok(Ids::ComAtprotoSyncSubscribeRepos),
-            "com.atproto.temp.checkSignupQueue" => Ok(Ids::ComAtprotoTempCheckSignupQueue),
-            "com.atproto.temp.fetchLabels" => Ok(Ids::ComAtprotoTempFetchLabels),
-            "com.atproto.temp.requestPhoneVerification" => {
-                Ok(Ids::ComAtprotoTempRequestPhoneVerification)
-            }
-            "app.bsky.actor.defs" => Ok(Ids::AppBskyActorDefs),
-            "app.bsky.actor.getPreferences" => Ok(Ids::AppBskyActorGetPreferences),
-            "app.bsky.actor.getProfile" => Ok(Ids::AppBskyActorGetProfile),
-            "app.bsky.actor.getProfiles" => Ok(Ids::AppBskyActorGetProfiles),
-            "app.bsky.actor.getSuggestions" => Ok(Ids::AppBskyActorGetSuggestions),
-            "app.bsky.actor.profile" => Ok(Ids::AppBskyActorProfile),
-            "app.bsky.actor.putPreferences" => Ok(Ids::AppBskyActorPutPreferences),
-            "app.bsky.actor.searchActors" => Ok(Ids::AppBskyActorSearchActors),
-            "app.bsky.actor.searchActorsTypeahead" => Ok(Ids::AppBskyActorSearchActorsTypeahead),
-            "app.bsky.embed.external" => Ok(Ids::AppBskyEmbedExternal),
-            "app.bsky.embed.images" => Ok(Ids::AppBskyEmbedImages),
-            "app.bsky.embed.record" => Ok(Ids::AppBskyEmbedRecord),
-            "app.bsky.embed.recordWithMedia" => Ok(Ids::AppBskyEmbedRecordWithMedia),
-            "app.bsky.feed.defs" => Ok(Ids::AppBskyFeedDefs),
-            "app.bsky.feed.describeFeedGenerator" => Ok(Ids::AppBskyFeedDescribeFeedGenerator),
-            "app.bsky.feed.generator" => Ok(Ids::AppBskyFeedGenerator),
-            "app.bsky.feed.getActorFeeds" => Ok(Ids::AppBskyFeedGetActorFeeds),
-            "app.bsky.feed.getActorLikes" => Ok(Ids::AppBskyFeedGetActorLikes),
-            "app.bsky.feed.getAuthorFeed" => Ok(Ids::AppBskyFeedGetAuthorFeed),
-            "app.bsky.feed.getFeed" => Ok(Ids::AppBskyFeedGetFeed),
-            "app.bsky.feed.getFeedGenerator" => Ok(Ids::AppBskyFeedGetFeedGenerator),
-            "app.bsky.feed.getFeedGenerators" => Ok(Ids::AppBskyFeedGetFeedGenerators),
-            "app.bsky.feed.getFeedSkeleton" => Ok(Ids::AppBskyFeedGetFeedSkeleton),
-            "app.bsky.feed.getLikes" => Ok(Ids::AppBskyFeedGetLikes),
-            "app.bsky.feed.getListFeed" => Ok(Ids::AppBskyFeedGetListFeed),
-            "app.bsky.feed.getPostThread" => Ok(Ids::AppBskyFeedGetPostThread),
-            "app.bsky.feed.getPosts" => Ok(Ids::AppBskyFeedGetPosts),
-            "app.bsky.feed.getRepostedBy" => Ok(Ids::AppBskyFeedGetRepostedBy),
-            "app.bsky.feed.getSuggestedFeeds" => Ok(Ids::AppBskyFeedGetSuggestedFeeds),
-            "app.bsky.feed.getTimeline" => Ok(Ids::AppBskyFeedGetTimeline),
-            "app.bsky.feed.like" => Ok(Ids::AppBskyFeedLike),
-            "app.bsky.feed.post" => Ok(Ids::AppBskyFeedPost),
-            "app.bsky.feed.repost" => Ok(Ids::AppBskyFeedRepost),
-            "app.bsky.feed.searchPosts" => Ok(Ids::AppBskyFeedSearchPosts),
-            "app.bsky.feed.threadgate" => Ok(Ids::AppBskyFeedThreadgate),
-            "app.bsky.graph.block" => Ok(Ids::AppBskyGraphBlock),
-            "app.bsky.graph.defs" => Ok(Ids::AppBskyGraphDefs),
-            "app.bsky.graph.follow" => Ok(Ids::AppBskyGraphFollow),
-            "app.bsky.graph.getBlocks" => Ok(Ids::AppBskyGraphGetBlocks),
-            "app.bsky.graph.getFollowers" => Ok(Ids::AppBskyGraphGetFollowers),
-            "app.bsky.graph.getFollows" => Ok(Ids::AppBskyGraphGetFollows),
-            "app.bsky.graph.getList" => Ok(Ids::AppBskyGraphGetList),
-            "app.bsky.graph.getListBlocks" => Ok(Ids::AppBskyGraphGetListBlocks),
-            "app.bsky.graph.getListMutes" => Ok(Ids::AppBskyGraphGetListMutes),
-            "app.bsky.graph.getLists" => Ok(Ids::AppBskyGraphGetLists),
-            "app.bsky.graph.getMutes" => Ok(Ids::AppBskyGraphGetMutes),
-            "app.bsky.graph.getRelationships" => Ok(Ids::AppBskyGraphGetRelationships),
-            "app.bsky.graph.getSuggestedFollowsByActor" => {
-                Ok(Ids::AppBskyGraphGetSuggestedFollowsByActor)
-            }
-            "app.bsky.graph.list" => Ok(Ids::AppBskyGraphList),
-            "app.bsky.graph.listblock" => Ok(Ids::AppBskyGraphListblock),
-            "app.bsky.graph.listitem" => Ok(Ids::AppBskyGraphListitem),
-            "app.bsky.graph.muteActor" => Ok(Ids::AppBskyGraphMuteActor),
-            "app.bsky.graph.muteActorList" => Ok(Ids::AppBskyGraphMuteActorList),
-            "app.bsky.graph.unmuteActor" => Ok(Ids::AppBskyGraphUnmuteActor),
-            "app.bsky.graph.unmuteActorList" => Ok(Ids::AppBskyGraphUnmuteActorList),
-            "app.bsky.labeler.defs" => Ok(Ids::AppBskyLabelerDefs),
-            "app.bsky.labeler.getServices" => Ok(Ids::AppBskyLabelerGetServices),
-            "app.bsky.labeler.service" => Ok(Ids::AppBskyLabelerService),
-            "app.bsky.notification.getUnreadCount" => Ok(Ids::AppBskyNotificationGetUnreadCount),
-            "app.bsky.notification.listNotifications" => {
-                Ok(Ids::AppBskyNotificationListNotifications)
-            }
-            "app.bsky.notification.registerPush" => Ok(Ids::AppBskyNotificationRegisterPush),
-            "app.bsky.notification.updateSeen" => Ok(Ids::AppBskyNotificationUpdateSeen),
-            "app.bsky.richtext.facet" => Ok(Ids::AppBskyRichtextFacet),
-            "app.bsky.unspecced.defs" => Ok(Ids::AppBskyUnspeccedDefs),
-            "app.bsky.unspecced.getPopularFeedGenerators" => {
-                Ok(Ids::AppBskyUnspeccedGetPopularFeedGenerators)
-            }
-            "app.bsky.unspecced.getTaggedSuggestions" => {
-                Ok(Ids::AppBskyUnspeccedGetTaggedSuggestions)
-            }
-            "app.bsky.unspecced.searchActorsSkeleton" => {
-                Ok(Ids::AppBskyUnspeccedSearchActorsSkeleton)
-            }
-            "app.bsky.unspecced.searchPostsSkeleton" => {
-                Ok(Ids::AppBskyUnspeccedSearchPostsSkeleton)
-            }
-            "tools.ozone.communication.createTemplate" => {
-                Ok(Ids::ToolsOzoneCommunicationCreateTemplate)
-            }
-            "tools.ozone.communication.defs" => Ok(Ids::ToolsOzoneCommunicationDefs),
-            "tools.ozone.communication.deleteTemplate" => {
-                Ok(Ids::ToolsOzoneCommunicationDeleteTemplate)
-            }
-            "tools.ozone.communication.listTemplates" => {
-                Ok(Ids::ToolsOzoneCommunicationListTemplates)
-            }
-            "tools.ozone.communication.updateTemplate" => {
-                Ok(Ids::ToolsOzoneCommunicationUpdateTemplate)
-            }
-            "tools.ozone.moderation.defs" => Ok(Ids::ToolsOzoneModerationDefs),
-            "tools.ozone.moderation.emitEvent" => Ok(Ids::ToolsOzoneModerationEmitEvent),
-            "tools.ozone.moderation.getEvent" => Ok(Ids::ToolsOzoneModerationGetEvent),
-            "tools.ozone.moderation.getRecord" => Ok(Ids::ToolsOzoneModerationGetRecord),
-            "tools.ozone.moderation.getRepo" => Ok(Ids::ToolsOzoneModerationGetRepo),
-            "tools.ozone.moderation.queryEvents" => Ok(Ids::ToolsOzoneModerationQueryEvents),
-            "tools.ozone.moderation.queryStatuses" => Ok(Ids::ToolsOzoneModerationQueryStatuses),
-            "tools.ozone.moderation.searchRepos" => Ok(Ids::ToolsOzoneModerationSearchRepos),
-            "tools.ozone.server.getConfig" => Ok(Ids::ToolsOzoneServerGetConfig),
-            "tools.ozone.team.addMember" => Ok(Ids::ToolsOzoneTeamAddMember),
-            "tools.ozone.team.defs" => Ok(Ids::ToolsOzoneTeamDefs),
-            "tools.ozone.team.deleteMember" => Ok(Ids::ToolsOzoneTeamDeleteMember),
-            "tools.ozone.team.listMembers" => Ok(Ids::ToolsOzoneTeamListMembers),
-            "tools.ozone.team.updateMember" => Ok(Ids::ToolsOzoneTeamUpdateMember),
-            "chat.bsky.actor.deleteAccount" => Ok(Ids::ChatBskyActorDeleteAccount),
-            "chat.bsky.actor.exportAccountData" => Ok(Ids::ChatBskyActorExportAccountData),
-            "chat.bsky.convo.deleteMessageForSelf" => Ok(Ids::ChatBskyConvoDeleteMessageForSelf),
-            "chat.bsky.convo.getConvo" => Ok(Ids::ChatBskyConvoGetConvo),
-            "chat.bsky.convo.getConvoForMembers" => Ok(Ids::ChatBskyConvoGetConvoForMembers),
-            "chat.bsky.convo.getLog" => Ok(Ids::ChatBskyConvoGetLog),
-            "chat.bsky.convo.getMessages" => Ok(Ids::ChatBskyConvoGetMessages),
-            "chat.bsky.convo.leaveConvo" => Ok(Ids::ChatBskyConvoLeaveConvo),
-            "chat.bsky.convo.listConvos" => Ok(Ids::ChatBskyConvoListConvos),
-            "chat.bsky.convo.muteConvo" => Ok(Ids::ChatBskyConvoMuteConvo),
-            "chat.bsky.convo.sendMessage" => Ok(Ids::ChatBskyConvoSendMessage),
-            "chat.bsky.convo.sendMessageBatch" => Ok(Ids::ChatBskyConvoSendMessageBatch),
-            "chat.bsky.convo.unmuteConvo" => Ok(Ids::ChatBskyConvoUnmuteConvo),
-            "chat.bsky.convo.updateRead" => Ok(Ids::ChatBskyConvoUpdateRead),
-            _ => bail!("Invalid NSID: `{s:?}` is not a valid nsid"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct RecordCidClaim {
-    pub collection: String,
-    pub rkey: String,
-    pub cid: Option<Cid>,
-}
-
-/// BlobStream
-/// A stream of blob data.
-pub(crate) struct BlobStream(Box<dyn std::io::Read + Send>);
-impl Debug for BlobStream {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("BlobStream").finish()
-    }
-}
-
-pub(crate) struct BlobStore;
-pub(crate) trait BlobStoreTrait {
-    async fn put_temp(&self, bytes: &[u8]) -> Result<String>; // bytes: Uint8Array | stream.Readable
-    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()>;
-    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()>;
-    async fn quarantine(&self, cid: Cid) -> Result<()>;
-    async fn unquarantine(&self, cid: Cid) -> Result<()>;
-    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>>;
-    async fn get_stream(&self, cid: Cid) -> Result<BlobStream>; // Promise<stream.Readable>
-    async fn has_temp(&self, key: &str) -> Result<bool>;
-    async fn has_stored(&self, cid: Cid) -> Result<bool>;
-    async fn delete(&self, cid: Cid) -> Result<()>;
-    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()>;
-}
-impl BlobStoreTrait for BlobStore {
-    async fn put_temp(&self, bytes: &[u8]) -> Result<String> {
-        // Implementation here
-        Ok("temp_key".to_string())
-    }
-
-    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()> {
-        // Implementation here
-        Ok(())
-    }
-
-    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()> {
-        // Implementation here
-        Ok(())
-    }
-
-    async fn quarantine(&self, cid: Cid) -> Result<()> {
-        // Implementation here
-        Ok(())
-    }
-
-    async fn unquarantine(&self, cid: Cid) -> Result<()> {
-        // Implementation here
-        Ok(())
-    }
-
-    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>> {
-        // Implementation here
-        Ok(vec![])
-    }
-
-    async fn get_stream(&self, cid: Cid) -> Result<BlobStream> {
-        // Implementation here
-        Ok(BlobStream(Box::new(std::io::empty())))
-    }
-
-    async fn has_temp(&self, key: &str) -> Result<bool> {
-        // Implementation here
-        Ok(true)
-    }
-
-    async fn has_stored(&self, cid: Cid) -> Result<bool> {
-        // Implementation here
-        Ok(true)
-    }
-    async fn delete(&self, cid: Cid) -> Result<()> {
-        // Implementation here
-        Ok(())
-    }
-    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
-        // Implementation here
-        Ok(())
-    }
-}