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 create_profile<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        profile: &'life1 Profile<&'life2 str>,
        etag: &'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 update_profile<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        id_tag: &'life1 str,
        profile: &'life2 UpdateProfileData,
    ) -> Pin<Box<dyn Future<Output = ClResult<()>> + 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,
    ) -> 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 process_profile_refresh<'a, 'life0, 'async_trait>(
        &'life0 self,
        callback: Box<dyn Fn(TnId, &'a str, Option<&'a str>) -> ClResult<()> + Send>,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait,
             'life0: 'async_trait;
    fn list_stale_profiles<'life0, 'async_trait>(
        &'life0 self,
        max_age_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 create_outbound_action<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        token: &'life2 str,
        opts: &'life3 CreateOutboundActionOptions,
    ) -> 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_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 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 add_reaction<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
        reactor_id_tag: &'life2 str,
        reaction_type: &'life3 str,
        content: Option<&'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 list_reactions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tn_id: TnId,
        action_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = ClResult<Vec<ReactionData>>> + 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_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;
}

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 create_profile<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tn_id: TnId, profile: &'life1 Profile<&'life2 str>, etag: &'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 update_profile<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tn_id: TnId, id_tag: &'life1 str, profile: &'life2 UpdateProfileData, ) -> Pin<Box<dyn Future<Output = ClResult<()>> + 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,

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, ) -> 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 process_profile_refresh<'a, 'life0, 'async_trait>( &'life0 self, callback: Box<dyn Fn(TnId, &'a str, Option<&'a str>) -> ClResult<()> + Send>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Process profile refresh callback(tn_id: TnId, id_tag: &str, etag: Option<&str>)

fn list_stale_profiles<'life0, 'async_trait>( &'life0 self, max_age_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 OR synced_at < now - max_age_secs. 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 create_outbound_action<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, token: &'life2 str, opts: &'life3 CreateOutboundActionOptions, ) -> 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,

Create outbound action

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 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 add_reaction<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tn_id: TnId, action_id: &'life1 str, reactor_id_tag: &'life2 str, reaction_type: &'life3 str, content: Option<&'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,

Add a reaction to an action

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

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

List all reactions for an action

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_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.

Implementors