Trait MetaAdapter 

pub trait MetaAdapter:
    Debug
    + Send
    + Sync {
    // Required methods
    fn read_tenant<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
    ) -> Pin<Box<dyn Future<Output = ClResult<Tenant<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_tenant<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<TnId>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_tenant<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        tenant: &'life1 UpdateTenantData,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_tenant<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_tenants<'life0, 'life1, 'async_trait>(
        &'life0 self,
        opts: &'life1 ListTenantsMetaOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<TenantListMeta>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_profiles<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        opts: &'life1 ListProfileOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Profile<Box<str>>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_relationships<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        target_id_tags: &'life1 [&'life2 str],
    ) -> Pin<Box<dyn Future<Output = ClResult<HashMap<String, (bool, bool)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn read_profile<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<(Box<str>, Profile<Box<str>>)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn read_profile_roles<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Box<[Box<str>]>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn upsert_profile<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
        fields: &'life2 UpsertProfileFields,
    ) -> Pin<Box<dyn Future<Output = ClResult<UpsertResult>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn read_profile_public_key<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        id_tag: &'life1 str,
        key_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<(Box<str>, Timestamp)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn add_profile_public_key<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        id_tag: &'life1 str,
        key_id: &'life2 str,
        public_key: &'life3 str,
        expires_at: Option<Timestamp>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn list_stale_profiles<'life0, 'async_trait>(
        &'life0 self,
        max_age_secs: i64,
        disable_after_secs: i64,
        limit: u32,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<(TnId, Box<str>, Option<Box<str>>)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_action_id<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        a_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_actions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        opts: &'life1 ListActionOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ActionView>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_action_tokens<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        opts: &'life1 ListActionOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<[Box<str>]>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn create_action<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action: &'life1 Action<&'life2 str>,
        key: Option<&'life3 str>,
    ) -> Pin<Box<dyn Future<Output = ClResult<ActionId<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn finalize_action<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        a_id: u64,
        action_id: &'life1 str,
        options: FinalizeActionOptions<'life2>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn create_inbound_action<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        token: &'life2 str,
        ack_token: Option<&'life3 str>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn get_action_root_id<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_action_data<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<ActionData>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_action_by_key<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_key: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Action<Box<str>>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn store_action_token<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        token: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_action_token<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_action_data<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        opts: &'life2 UpdateActionDataOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn update_inbound_action<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        status: Option<char>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_related_action_tokens<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        aprv_action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<(Box<str>, Box<str>)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_file_id<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        f_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_files<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        opts: &'life1 ListFileOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<FileView>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_file_variants<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: FileId<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<FileVariant<Box<str>>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_available_variants<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn read_file_variant<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        variant_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<FileVariant<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn read_file_id_by_variant<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        variant_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn read_f_id_by_file_id<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<u64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn create_file<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        opts: CreateFile,
    ) -> Pin<Box<dyn Future<Output = ClResult<FileId<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_file_variant<'a, 'async_trait>(
        &'a self,
        tn_id: TnId,
        f_id: u64,
        opts: FileVariant<&'a str>,
    ) -> Pin<Box<dyn Future<Output = ClResult<&'a str>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait;
    fn update_file_id<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        f_id: u64,
        file_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn finalize_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        f_id: u64,
        file_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_tasks<'life0, 'async_trait>(
        &'life0 self,
        opts: ListTaskOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Task>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_task_ids<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        kind: &'life1 str,
        keys: &'life2 [Box<str>],
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<u64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn create_task<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        kind: &'static str,
        key: Option<&'life1 str>,
        input: &'life2 str,
        deps: &'life3 [u64],
    ) -> Pin<Box<dyn Future<Output = ClResult<u64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn update_task_finished<'life0, 'life1, 'async_trait>(
        &'life0 self,
        task_id: u64,
        output: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_task_error<'life0, 'life1, 'async_trait>(
        &'life0 self,
        task_id: u64,
        output: &'life1 str,
        next_at: Option<Timestamp>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn find_task_by_key<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Task>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_task<'life0, 'life1, 'async_trait>(
        &'life0 self,
        task_id: u64,
        patch: &'life1 TaskPatch,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn find_completed_deps<'life0, 'life1, 'async_trait>(
        &'life0 self,
        deps: &'life1 [u64],
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<u64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_profile_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<ProfileData>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_action<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<ActionView>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_action<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        content: Option<&'life2 str>,
        attachments: Option<&'life3 [&'life4 str]>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn delete_action<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn count_reactions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        subject_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_children_by_root<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        root_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Box<str>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_settings<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        prefix: Option<&'life1 [String]>,
    ) -> Pin<Box<dyn Future<Output = ClResult<HashMap<String, Value>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn read_setting<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        name: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Value>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_setting<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        name: &'life1 str,
        value: Option<Value>,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_refs<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        opts: &'life1 ListRefsOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<RefData>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_ref<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ref_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<(Box<str>, Box<str>)>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn create_ref<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ref_id: &'life1 str,
        opts: &'life2 CreateRefOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<RefData>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn delete_ref<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ref_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn use_ref<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ref_id: &'life1 str,
        expected_types: &'life2 [&'life3 str],
    ) -> Pin<Box<dyn Future<Output = ClResult<(TnId, Box<str>, RefData)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn validate_ref<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ref_id: &'life1 str,
        expected_types: &'life2 [&'life3 str],
    ) -> Pin<Box<dyn Future<Output = ClResult<(TnId, Box<str>, RefData)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn list_tags<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        prefix: Option<&'life1 str>,
        with_counts: bool,
        limit: Option<u32>,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<TagInfo>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn add_tag<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
        tag: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn remove_tag<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
        tag: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn update_file_data<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
        opts: &'life2 UpdateFileOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn read_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        file_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<FileView>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn record_file_access<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
        file_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn record_file_modification<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
        file_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn update_file_user_data<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
        file_id: &'life2 str,
        pinned: Option<bool>,
        starred: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = ClResult<FileUserData>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_file_user_data<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
        file_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<FileUserData>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn list_push_subscriptions<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<PushSubscription>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_push_subscription<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        subscription: &'life1 PushSubscriptionData,
    ) -> Pin<Box<dyn Future<Output = ClResult<u64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_push_subscription<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        subscription_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_share_entry<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        resource_type: char,
        resource_id: &'life1 str,
        created_by: &'life2 str,
        entry: &'life3 CreateShareEntry,
    ) -> Pin<Box<dyn Future<Output = ClResult<ShareEntry>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn delete_share_entry<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id: i64,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_share_entries<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        resource_type: char,
        resource_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ShareEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_share_entries_by_subject<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        subject_type: Option<char>,
        subject_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ShareEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn check_share_access<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        resource_type: char,
        resource_id: &'life1 str,
        subject_type: char,
        subject_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<char>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn read_share_entry<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id: i64,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<ShareEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn install_app<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        install: &'life1 InstallApp,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn uninstall_app<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        app_name: &'life1 str,
        publisher_tag: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn list_installed_apps<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        search: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<InstalledApp>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_installed_app<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        app_name: &'life1 str,
        publisher_tag: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<InstalledApp>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn create_address_book<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        name: &'life1 str,
        description: Option<&'life2 str>,
    ) -> Pin<Box<dyn Future<Output = ClResult<AddressBook>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn list_address_books<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<AddressBook>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_address_book<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<AddressBook>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_address_book_by_name<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        name: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<AddressBook>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_address_book<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
        patch: &'life1 UpdateAddressBookData,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_address_book<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_contacts<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: Option<u64>,
        opts: &'life1 ListContactOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ContactView>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_contact<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
        uid: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Contact>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn upsert_contact<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
        uid: &'life1 str,
        vcard: &'life2 str,
        etag: &'life3 str,
        extracted: &'life4 ContactExtracted,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn delete_contact<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
        uid: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_contacts_by_uids<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
        uids: &'life1 [&'life2 str],
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Contact>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn list_contacts_since<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        ab_id: u64,
        since: Option<Timestamp>,
        limit: Option<u32>,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ContactSyncEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_contacts_by_profile<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        profile_id_tag: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Contact>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn create_calendar<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        input: &'life1 CreateCalendarData,
    ) -> Pin<Box<dyn Future<Output = ClResult<Calendar>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_calendars<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Calendar>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_calendar<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Calendar>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_calendar_by_name<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        name: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<Calendar>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update_calendar<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        patch: &'life1 UpdateCalendarData,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_calendar<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_calendar_objects<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        opts: &'life1 ListCalendarObjectOptions,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObjectView>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_calendar_object<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uid: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<CalendarObject>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_calendar_object_override<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uid: &'life1 str,
        recurrence_id: Timestamp,
    ) -> Pin<Box<dyn Future<Output = ClResult<Option<CalendarObject>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_calendar_object_overrides<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uid: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObject>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_calendar_object_override<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uid: &'life1 str,
        recurrence_id: Timestamp,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn upsert_calendar_object<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uid: &'life1 str,
        ical: &'life2 str,
        etag: &'life3 str,
        extracted: &'life4 CalendarObjectExtracted,
    ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn delete_calendar_object<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uid: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn split_calendar_object_series<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        master: CalendarObjectWrite<'life1>,
        tail: CalendarObjectWrite<'life2>,
        split_at: Timestamp,
    ) -> Pin<Box<dyn Future<Output = ClResult<(Box<str>, Box<str>)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_calendar_objects_by_uids<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        uids: &'life1 [&'life2 str],
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObject>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn list_calendar_objects_since<'life0, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        since: Option<Timestamp>,
        limit: Option<u32>,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObjectSyncEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn query_calendar_objects_in_range<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        cal_id: u64,
        component: Option<&'life1 str>,
        start: Option<Timestamp>,
        end: Option<Timestamp>,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObject>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

Required Methods

fn read_tenant<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ) -> Pin<Box<dyn Future<Output = ClResult<Tenant<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reads a tenant profile

fn create_tenant<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<TnId>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Creates a new tenant

fn update_tenant<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, tenant: &'life1 UpdateTenantData, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Updates a tenant

fn delete_tenant<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Deletes a tenant

fn list_tenants<'life0, 'life1, 'async_trait>( &'life0 self, opts: &'life1 ListTenantsMetaOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<TenantListMeta>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lists all tenants (for admin use)

fn list_profiles<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, opts: &'life1 ListProfileOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Profile<Box<str>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lists all profiles matching a set of options

fn get_relationships<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, target_id_tags: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = ClResult<HashMap<String, (bool, bool)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get relationships between the current user and multiple target profiles

Efficiently queries relationship status (following, connected) for multiple profiles in a single database call, avoiding N+1 query patterns.

Returns: HashMap<target_id_tag, (following: bool, connected: bool)>

fn read_profile<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<(Box<str>, Profile<Box<str>>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads a profile

Returns an (etag, Profile) tuple.

fn read_profile_roles<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Box<[Box<str>]>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read profile roles for access token generation

fn upsert_profile<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, fields: &'life2 UpsertProfileFields, ) -> Pin<Box<dyn Future<Output = ClResult<UpsertResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert a profile row if missing, otherwise update it.

Returns UpsertResult::Created if the row was inserted, or UpsertResult::Updated if an existing row was updated. Never returns Error::Conflict or Error::NotFound — the operation is idempotent with respect to row existence.

fn read_profile_public_key<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id_tag: &'life1 str, key_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<(Box<str>, Timestamp)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Reads the public key of a profile

Returns a (public key, expiration) tuple.

fn add_profile_public_key<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, id_tag: &'life1 str, key_id: &'life2 str, public_key: &'life3 str, expires_at: Option<Timestamp>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Cache a federated profile public key.

expires_at is the owner-declared key expiration from the remote profile. None means the owner did not declare an expiration; the implementation may store it as NULL (treated as “never expires” by read_profile_public_key).

fn list_stale_profiles<'life0, 'async_trait>( &'life0 self, max_age_secs: i64, disable_after_secs: i64, limit: u32, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<(TnId, Box<str>, Option<Box<str>>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List stale profiles that need refreshing

Returns profiles where:

• synced_at IS NULL (never synced — always eligible), OR
• synced_at < now - max_age_secs AND synced_at >= now - disable_after_secs (stale but not yet abandoned).

Profiles with synced_at < now - disable_after_secs are excluded so the refresh batch stops attempting persistently failing remotes. Returns Vec<(tn_id, id_tag, etag)> tuples for conditional refresh requests.

fn get_action_id<'life0, 'async_trait>( &'life0 self, tn_id: TnId, a_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_actions<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, opts: &'life1 ListActionOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ActionView>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_action_tokens<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, opts: &'life1 ListActionOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Box<[Box<str>]>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_action<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tn_id: TnId, action: &'life1 Action<&'life2 str>, key: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = ClResult<ActionId<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn finalize_action<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, a_id: u64, action_id: &'life1 str, options: FinalizeActionOptions<'life2>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn create_inbound_action<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, token: &'life2 str, ack_token: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn get_action_root_id<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the root_id of an action

fn get_action_data<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<ActionData>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get action data (subject, reaction count, comment count)

fn get_action_by_key<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_key: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Action<Box<str>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get action by key

fn store_action_token<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, token: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store action token for federation (called when action is created)

fn get_action_token<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get action token for federation

fn update_action_data<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, opts: &'life2 UpdateActionDataOptions, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update action data (subject, reactions, comments, status)

fn update_inbound_action<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, status: Option<char>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update inbound action status

fn get_related_action_tokens<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, aprv_action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<(Box<str>, Box<str>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get related action tokens by APRV action_id Returns list of (action_id, token) pairs for actions that have ack = aprv_action_id

fn get_file_id<'life0, 'async_trait>( &'life0 self, tn_id: TnId, f_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_files<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, opts: &'life1 ListFileOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<FileView>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_file_variants<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, file_id: FileId<&'life1 str>, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<FileVariant<Box<str>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_available_variants<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List locally available variant names for a file (only those marked available)

fn read_file_variant<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, variant_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<FileVariant<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn read_file_id_by_variant<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, variant_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up the file_id for a given variant_id

fn read_f_id_by_file_id<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up the internal f_id for a given file_id (for adding variants to existing files)

fn create_file<'life0, 'async_trait>( &'life0 self, tn_id: TnId, opts: CreateFile, ) -> Pin<Box<dyn Future<Output = ClResult<FileId<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_file_variant<'a, 'async_trait>( &'a self, tn_id: TnId, f_id: u64, opts: FileVariant<&'a str>, ) -> Pin<Box<dyn Future<Output = ClResult<&'a str>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

fn update_file_id<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, f_id: u64, file_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn finalize_file<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, f_id: u64, file_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Finalize a pending file - sets file_id and transitions status from ‘P’ to ‘A’ atomically

fn list_tasks<'life0, 'async_trait>( &'life0 self, opts: ListTaskOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Task>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_task_ids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, kind: &'life1 str, keys: &'life2 [Box<str>], ) -> Pin<Box<dyn Future<Output = ClResult<Vec<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn create_task<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, kind: &'static str, key: Option<&'life1 str>, input: &'life2 str, deps: &'life3 [u64], ) -> Pin<Box<dyn Future<Output = ClResult<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn update_task_finished<'life0, 'life1, 'async_trait>( &'life0 self, task_id: u64, output: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn update_task_error<'life0, 'life1, 'async_trait>( &'life0 self, task_id: u64, output: &'life1 str, next_at: Option<Timestamp>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn find_task_by_key<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Task>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a pending task by its key

fn update_task<'life0, 'life1, 'async_trait>( &'life0 self, task_id: u64, patch: &'life1 TaskPatch, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update task fields with partial updates

fn find_completed_deps<'life0, 'life1, 'async_trait>( &'life0 self, deps: &'life1 [u64], ) -> Pin<Box<dyn Future<Output = ClResult<Vec<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find deps that have completed (status != ‘P’)

fn get_profile_info<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<ProfileData>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a single profile by id_tag

fn get_action<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<ActionView>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a single action by action_id

fn update_action<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, content: Option<&'life2 str>, attachments: Option<&'life3 [&'life4 str]>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Update action content and attachments (if not yet federated)

fn delete_action<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an action (soft delete with cleanup)

fn count_reactions<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, subject_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count active (non-DEL, non-deleted) REACT actions for a given subject, grouped by type Returns colon-separated format: “L5:V3:W1” (Like=5, Love=3, Wow=1)

fn delete_file<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a file (set status to ‘D’)

fn list_children_by_root<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, root_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Box<str>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all child files in a document tree (files with the given root_id)

fn list_settings<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, prefix: Option<&'life1 [String]>, ) -> Pin<Box<dyn Future<Output = ClResult<HashMap<String, Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all settings for a tenant, optionally filtered by prefix

fn read_setting<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a single setting by name

fn update_setting<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, name: &'life1 str, value: Option<Value>, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update or delete a setting (None = delete)

fn list_refs<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, opts: &'life1 ListRefsOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<RefData>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all references for a tenant

fn get_ref<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, ref_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<(Box<str>, Box<str>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a specific reference by ID

fn create_ref<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, ref_id: &'life1 str, opts: &'life2 CreateRefOptions, ) -> Pin<Box<dyn Future<Output = ClResult<RefData>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new reference

fn delete_ref<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, ref_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a reference

fn use_ref<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ref_id: &'life1 str, expected_types: &'life2 [&'life3 str], ) -> Pin<Box<dyn Future<Output = ClResult<(TnId, Box<str>, RefData)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Use/consume a reference - validates type, expiration, counter, decrements counter Returns (TnId, id_tag, RefData) of the tenant that owns this ref

fn validate_ref<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ref_id: &'life1 str, expected_types: &'life2 [&'life3 str], ) -> Pin<Box<dyn Future<Output = ClResult<(TnId, Box<str>, RefData)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Validate a reference without consuming it - checks type, expiration, counter Returns (TnId, id_tag, RefData) of the tenant that owns this ref if valid

fn list_tags<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, prefix: Option<&'life1 str>, with_counts: bool, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<TagInfo>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all tags for a tenant

Arguments

• tn_id - Tenant ID
• prefix - Optional prefix filter
• with_counts - If true, include file counts per tag
• limit - Optional limit on number of tags returned

fn add_tag<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, tag: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Add a tag to a file

fn remove_tag<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, tag: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remove a tag from a file

fn update_file_data<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, opts: &'life2 UpdateFileOptions, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update file metadata (name, visibility, status)

fn read_file<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, file_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<FileView>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read file metadata

fn record_file_access<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, file_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Record file access for a user (upserts record, updates accessed_at timestamp)

fn record_file_modification<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, file_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Record file modification for a user (upserts record, updates modified_at timestamp)

fn update_file_user_data<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, file_id: &'life2 str, pinned: Option<bool>, starred: Option<bool>, ) -> Pin<Box<dyn Future<Output = ClResult<FileUserData>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update file user data (pinned/starred status)

fn get_file_user_data<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, file_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<FileUserData>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get file user data for a specific file

fn list_push_subscriptions<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<PushSubscription>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List all push subscriptions for a tenant (user)

Returns all active push subscriptions for this tenant. Each tenant represents a user, so this returns all their device subscriptions.

fn create_push_subscription<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, subscription: &'life1 PushSubscriptionData, ) -> Pin<Box<dyn Future<Output = ClResult<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a new push subscription

Stores a Web Push subscription for a tenant. The subscription contains the endpoint URL and encryption keys needed to send push notifications. Returns the generated subscription ID.

fn delete_push_subscription<'life0, 'async_trait>( &'life0 self, tn_id: TnId, subscription_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete a push subscription by ID

Removes a push subscription. Called when a subscription becomes invalid (e.g., 410 Gone response from push service) or when user unsubscribes.

fn create_share_entry<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tn_id: TnId, resource_type: char, resource_id: &'life1 str, created_by: &'life2 str, entry: &'life3 CreateShareEntry, ) -> Pin<Box<dyn Future<Output = ClResult<ShareEntry>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a share entry (idempotent on unique constraint)

fn delete_share_entry<'life0, 'async_trait>( &'life0 self, tn_id: TnId, id: i64, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete a share entry by ID

fn list_share_entries<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, resource_type: char, resource_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ShareEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List share entries for a resource

fn list_share_entries_by_subject<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, subject_type: Option<char>, subject_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ShareEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List share entries by subject (reverse lookup). If subject_type is None, matches all subject types.

fn check_share_access<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, resource_type: char, resource_id: &'life1 str, subject_type: char, subject_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<char>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Check if a subject has share access to a resource Returns the permission char if access exists, None otherwise

fn read_share_entry<'life0, 'async_trait>( &'life0 self, tn_id: TnId, id: i64, ) -> Pin<Box<dyn Future<Output = ClResult<Option<ShareEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read a single share entry by ID (for delete validation)

fn install_app<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, install: &'life1 InstallApp, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Install an app package

fn uninstall_app<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, app_name: &'life1 str, publisher_tag: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Uninstall an app by name and publisher

fn list_installed_apps<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, search: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<InstalledApp>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List installed apps, optionally filtered by search term

fn get_installed_app<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, app_name: &'life1 str, publisher_tag: &'life2 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<InstalledApp>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a specific installed app

fn create_address_book<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, name: &'life1 str, description: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = ClResult<AddressBook>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new address book collection.

fn list_address_books<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<AddressBook>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List all address books for a tenant.

fn get_address_book<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<Option<AddressBook>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read a single address book by id.

fn get_address_book_by_name<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<AddressBook>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up an address book by its name (for CardDAV path routing).

fn update_address_book<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, patch: &'life1 UpdateAddressBookData, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Patch an address book’s metadata.

fn delete_address_book<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete an address book (and all its contacts).

fn list_contacts<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: Option<u64>, opts: &'life1 ListContactOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ContactView>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List + search contacts. When ab_id is Some, scopes to that book (cursor is c_id-ordered). When None, queries across all books sorted by name.

fn get_contact<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, uid: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Contact>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a single contact (including vCard blob) by UID.

fn upsert_contact<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, uid: &'life1 str, vcard: &'life2 str, etag: &'life3 str, extracted: &'life4 ContactExtracted, ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Insert or update a contact (keyed by UID). Also bumps the address book’s ctag. Returns the new etag.

fn delete_contact<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, uid: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Soft-delete a contact (sets deleted_at), leaving a tombstone row for CardDAV sync. Also bumps the address book’s ctag.

fn get_contacts_by_uids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, uids: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Contact>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch multiple contacts by UID — for CardDAV addressbook-multiget REPORT.

fn list_contacts_since<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ab_id: u64, since: Option<Timestamp>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ContactSyncEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return live + tombstone entries for CardDAV sync-collection REPORT. since is the sync token’s timestamp; None means full sync. limit caps the number of rows returned; callers supply their own hard ceiling to keep responses bounded. None means no client-supplied limit — callers should still pass their server-side ceiling.

fn list_contacts_by_profile<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, profile_id_tag: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Contact>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all contacts linked to a given profile id_tag (for bulk snapshot refresh).

fn create_calendar<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, input: &'life1 CreateCalendarData, ) -> Pin<Box<dyn Future<Output = ClResult<Calendar>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a new calendar collection.

fn list_calendars<'life0, 'async_trait>( &'life0 self, tn_id: TnId, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<Calendar>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List all calendars for a tenant.

fn get_calendar<'life0, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Calendar>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read a single calendar by id.

fn get_calendar_by_name<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<Calendar>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up a calendar by its name (for CalDAV path routing).

fn update_calendar<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, patch: &'life1 UpdateCalendarData, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Patch a calendar’s metadata.

fn delete_calendar<'life0, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete a calendar (and all its objects).

fn list_calendar_objects<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, opts: &'life1 ListCalendarObjectOptions, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObjectView>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List + search calendar objects within a calendar. Excludes soft-deleted rows.

fn get_calendar_object<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uid: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Option<CalendarObject>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a single calendar object (including iCalendar blob) by UID. Returns the master row; recurrence-override rows live under the same UID but distinct recurrence_id and are not merged here.

fn get_calendar_object_override<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uid: &'life1 str, recurrence_id: Timestamp, ) -> Pin<Box<dyn Future<Output = ClResult<Option<CalendarObject>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a single recurrence-override row keyed by (uid, recurrence_id).

fn list_calendar_object_overrides<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uid: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObject>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all non-deleted recurrence-override rows for a given master UID.

fn delete_calendar_object_override<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uid: &'life1 str, recurrence_id: Timestamp, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Soft-delete a single recurrence-override row (leaves the master untouched).

fn upsert_calendar_object<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uid: &'life1 str, ical: &'life2 str, etag: &'life3 str, extracted: &'life4 CalendarObjectExtracted, ) -> Pin<Box<dyn Future<Output = ClResult<Box<str>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Insert or update a calendar object (keyed by UID). Also bumps the calendar’s ctag. Returns the new etag. The extracted.recurrence_id selects which row is written — the master row has None, recurrence overrides carry their own timestamp.

fn delete_calendar_object<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uid: &'life1 str, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Soft-delete a calendar object by UID (sets deleted_at on all rows sharing that UID), leaving tombstones for CalDAV sync. Also bumps the calendar’s ctag.

fn split_calendar_object_series<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, master: CalendarObjectWrite<'life1>, tail: CalendarObjectWrite<'life2>, split_at: Timestamp, ) -> Pin<Box<dyn Future<Output = ClResult<(Box<str>, Box<str>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically split a recurring series at split_at:

1. Upsert the existing master (typically with a truncated RRULE) using the caller-supplied ical / etag / extracted projection.
2. Soft-delete every override row whose recurrence_id >= split_at.
3. Insert the tail as a new master under its own UID.
4. Bump the calendar’s ctag once for the whole fork.

The whole operation runs in a single transaction; on any error the caller sees the original series unchanged. Returns the stored etags of the master and the tail, in that order.

fn get_calendar_objects_by_uids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, uids: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObject>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch multiple calendar objects by UID — for CalDAV calendar-multiget REPORT.

fn list_calendar_objects_since<'life0, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, since: Option<Timestamp>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObjectSyncEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return live + tombstone entries for CalDAV sync-collection REPORT. since is the sync token’s timestamp; None means full sync.

fn query_calendar_objects_in_range<'life0, 'life1, 'async_trait>( &'life0 self, tn_id: TnId, cal_id: u64, component: Option<&'life1 str>, start: Option<Timestamp>, end: Option<Timestamp>, ) -> Pin<Box<dyn Future<Output = ClResult<Vec<CalendarObject>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return calendar objects overlapping a time range — for CalDAV calendar-query REPORT. Semantics are deliberately loose (superset): any object whose master dtstart is ≤ end AND (rrule is set OR dtend is ≥ start OR dtend IS NULL) is returned. Clients expand recurrence locally. A None component lists both VEVENT and VTODO.

Implementors