@messenger-box/platform-server 10.0.3-alpha.7 → 10.0.3-alpha.74

package/lib/templates/repositories/ReactionRepository.ts.template

@@ -1,4 +1,3 @@
-import { IReaction, IReactionInput } from 'common';
-import { IBaseRepository } from '@common-stack/store-mongo';
-
-export type IReactionRepository = IBaseRepository<IReaction, IReactionInput>;
+import { IReactionInput,IBaseMongoRepository,IReactionModel } from 'common/server';
+//export type IReactionRepository = IBaseRepository<IReaction, IReactionInput>;
+export type IReactionRepository = IBaseMongoRepository<IReactionModel>;

package/lib/templates/services/AiFragmentService.ts.template

@@ -0,0 +1,123 @@
+/**
+ * AI Fragment Service Interface
+ * ----------------------------
+ * 
+ * This interface defines the business logic layer for AI fragment management within
+ * the messenger platform. It provides a comprehensive set of operations for
+ * handling AI-generated code fragments, sandbox management, and file synchronization.
+ * 
+ * Key capabilities:
+ * - AI fragment creation and management
+ * - Sandbox URL management
+ * - File version control and synchronization
+ * - Canvas layer support
+ * - Template-based fragment generation
+ * - Organization and user-based fragment retrieval
+ */
+
+import { IAiFragmentModel, IBaseService, AsDomainType, Disposable, IAiFragmentCreateInput, IAiFragmentUpdateInput, AiFragmentSyncStatus } from 'common/server';
+
+
+
+export interface AgentState {
+    summary: string;
+    files: { [path: string]: string };
+    canvasLayers?: any[];
+}
+
+export interface IAiFragmentService extends IBaseService<IAiFragmentModel>, Disposable {
+    /**
+     * Creates a new AI fragment with the specified parameters
+     * 
+     * @param {IAiFragmentCreateInput} input - The fragment creation data
+     * @returns {Promise<AsDomainType<IAiFragmentModel>>}
+     */
+    createFragment(input: IAiFragmentCreateInput): Promise<AsDomainType<IAiFragmentModel>>;
+
+    /**
+     * Retrieves an AI fragment by its message ID
+     * 
+     * @param {string} messageId - The message ID to search for
+     * @returns {Promise<AsDomainType<IAiFragmentModel> | null>}
+     */
+    getFragmentByMessageId(messageId: string): Promise<AsDomainType<IAiFragmentModel> | null>;
+
+    /**
+     * Retrieves AI fragments for a specific user and organization
+     * 
+     * @param {string} orgName - Organization name
+     * @param {string} owner - Owner identifier
+     * @param {number} [limit=20] - Maximum number of fragments to return
+     * @param {number} [skip=0] - Number of fragments to skip
+     * @returns {Promise<AsDomainType<IAiFragmentModel>[]>}
+     */
+    getFragmentsByUser(orgName: string, owner: string, limit?: number, skip?: number): Promise<AsDomainType<IAiFragmentModel>[]>;
+
+    /**
+     * Updates the files associated with a fragment
+     * 
+     * @param {string} messageId - The message ID of the fragment to update
+     * @param {Record<string, any>} files - The new files data
+     * @returns {Promise<AsDomainType<IAiFragmentModel> | null>}
+     */
+    updateFragmentFiles(messageId: string, files: Record<string, any>): Promise<AsDomainType<IAiFragmentModel> | null>;
+
+    /**
+     * Deletes an AI fragment by its ID
+     * 
+     * @param {string} id - The fragment ID to delete
+     * @returns {Promise<boolean>}
+     */
+    deleteFragment(id: string): Promise<boolean>;
+
+    /**
+     * Deletes an AI fragment by its message ID
+     * 
+     * @param {string} messageId - The message ID of the fragment to delete
+     * @returns {Promise<boolean>}
+     */
+    deleteFragmentByMessageId(messageId: string): Promise<boolean>;
+
+    /**
+     * Retrieves an AI fragment by its ID
+     * 
+     * @param {string} fragmentId - The fragment ID to retrieve
+     * @returns {Promise<AsDomainType<IAiFragmentModel> | null>}
+     */
+    getFragmentById(fragmentId: string): Promise<AsDomainType<IAiFragmentModel> | null>;
+
+    /**
+     * Updates the sandbox URL for a fragment
+     * 
+     * @param {string} fragmentId - The fragment ID to update
+     * @param {string} newSandboxUrl - The new sandbox URL
+     * @returns {Promise<AsDomainType<IAiFragmentModel> | null>}
+     */
+    updateSandboxUrl(fragmentId: string, newSandboxUrl: string): Promise<AsDomainType<IAiFragmentModel> | null>;
+
+    /**
+     * Updates file synchronization status and versions
+     * 
+     * @param {string} fragmentId - The fragment ID to update
+     * @param {Record<string, number>} fileVersions - File version mapping
+     * @param {AiFragmentSyncStatus} syncStatus - Current synchronization status
+     * @returns {Promise<AsDomainType<IAiFragmentModel> | null>}
+     */
+    updateFileSync(fragmentId: string, fileVersions: Record<string, number>, syncStatus: AiFragmentSyncStatus): Promise<AsDomainType<IAiFragmentModel> | null>;
+
+    /**
+     * Updates both files and synchronization status in a single operation
+     * 
+     * @param {string} messageId - The message ID of the fragment to update
+     * @param {Record<string, any>} files - The new files data
+     * @param {Record<string, number>} fileVersions - File version mapping
+     * @param {AiFragmentSyncStatus} syncStatus - Current synchronization status
+     * @returns {Promise<AsDomainType<IAiFragmentModel> | null>}
+     */
+    updateFilesAndSync(messageId: string, files: Record<string, any>, fileVersions: Record<string, number>, syncStatus: AiFragmentSyncStatus): Promise<AsDomainType<IAiFragmentModel> | null>;
+
+    /**
+     * Disposes of resources used by the service
+     */
+    dispose(): void;
+}

package/lib/templates/services/ChannelService.ts.template

@@ -1,6 +1,28 @@
-import { IBaseService } from '@common-stack/store-mongo';
-import { IChannel,RoomType, IChannelUnread, IPost, IUserAccount, Maybe, Scalars } from 'common';
-
+/**
+ * Channel Service Interface
+ * -------------------------
+ * 
+ * This interface defines the business logic layer for channel management within
+ * the messenger platform. It provides a comprehensive set of operations for
+ * managing channels, their members, and related messaging workflows.
+ * 
+ * Key capabilities:
+ * - Channel lifecycle management (creation, updates, deletion)
+ * - Member management (adding, removing, role assignment)
+ * - Direct and public channel handling
+ * - Message and post management within channels
+ * - Channel visibility and access control
+ * - Notification and unread message tracking
+ * - Team-based channel organization
+ * - Channel discovery and filtering
+ * 
+ * The service layer abstracts the underlying data access operations and
+ * provides a cohesive API for channel-related functionality throughout
+ * the messaging platform, handling complex business rules and cross-cutting concerns.
+ */
+
+
+import { IChannelModel, RoomType, IChannelUnread, IPost, IUserAccount, Maybe, Scalars, Disposable, AsDomainType,IBaseService, IChannelInput } from 'common/server';
 
 export interface INotificationProps {
     desktopNotifyProp: boolean;
@@ -18,38 +40,40 @@ export interface IDirectChannelMemberCreate {
     explicitRoles?: string;
 }
 
-export interface ISaveDirectChannelParams extends Omit<IChannel, 'creator' | 'id' | 'type' | 'members'> {
+export interface ISaveDirectChannelParams extends Omit<IChannelModel, 'creator' | 'id' | 'type' | 'members'> {
     type: RoomType.Direct;
     creator: string;
     displayName: string;
     members: any;
 }
 
-export interface ISaveChannelParams extends Omit<IChannel, 'creator' | 'id' | 'type' | 'team'> {
+export interface ISaveChannelParams extends Omit<IChannelModel, 'creator' | 'id' | 'type' | 'team'> {
     type: RoomType;
     creator: string;
     team: string;
     orgName: string;
+    organization: any;
+    projectId?: any;
 }
 
-export interface IAddMemberParams extends Omit<IChannel, 'channelId' | 'memberId'> {
+export interface IAddMemberParams extends Omit<IChannelModel, 'channelId' | 'memberId'> {
     memberId: string;
     channelId: string;
 }
 
-export interface ISavePublicChannelParams extends Omit<IChannel, 'creator' | 'id' | 'orgName' | 'team'> {
+export interface ISavePublicChannelParams extends Omit<IChannelModel, 'creator' | '_id' | 'orgName' | 'organization' | 'team'> {
     _id?: any;
     type: RoomType.Public;
     title: string;
 }
 
-
 export interface ICreateDirectChannelParams {
     sender: string;
     receiver: string[];
     displayName: string;
     channelOptions?: Record<string, unknown>;
     orgName?: string;
+    organization: any;
 }
 
 export interface ISaveMembersToChannelParams {
@@ -57,88 +81,315 @@ export interface ISaveMembersToChannelParams {
     channelId: string;
 }
 
-// based on https://github.com/mattermost/mattermost-server/blob/master/store/sqlstore/channel_store.go
-export interface IChannelService extends IBaseService<IChannel, Omit<IChannel, 'id'>> {
+// Based on https://github.com/mattermost/mattermost-server/blob/master/store/sqlstore/channel_store.go
+export interface IChannelService extends IBaseService<IChannelModel>, Disposable {
     /**
-     * @description Direct channel don't need team reference.
-     * @param data
+     * Creates a direct channel between users
+     * 
+     * @description Direct channels don't need team reference and are used for
+     * private conversations between specific users.
+     * 
+     * @param {ICreateDirectChannelParams} data - The direct channel creation parameters
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The created channel or error
      */
-    createDirectChannel(data: ICreateDirectChannelParams): Promise<IChannel | Error>;
+    createDirectChannel(data: ICreateDirectChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
 
+    /**
+     * Checks if a user is a member of a specific channel
+     * 
+     * @param {string} channelId - The ID of the channel to check
+     * @param {string} user - The ID of the user
+     * @returns {Promise<boolean>} - True if the user is a member
+     */
     isMember(channelId: string, user: string): Promise<boolean>;
 
-    addMemberToChannel(channelId: string, memberId: string): Promise<IChannel | Error>;
+    /**
+     * Adds a single member to a channel
+     * 
+     * @param {string} channelId - The ID of the channel
+     * @param {string} memberId - The ID of the member to add
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The updated channel or error
+     */
+    addMemberToChannel(channelId: string, memberId: string): Promise<AsDomainType<IChannelModel> | Error>;
 
-    saveMembersToChannel(data: ISaveMembersToChannelParams): Promise<IChannel | Error>;
+    /**
+     * Adds multiple members to a channel in a single operation
+     * 
+     * @param {ISaveMembersToChannelParams} data - The members and channel data
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The updated channel or error
+     */
+    saveMembersToChannel(data: ISaveMembersToChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
 
-    saveDirectChannel(channel: ISaveDirectChannelParams): Promise<IChannel | Error>;
+    /**
+     * Creates and saves a direct channel
+     * 
+     * @param {ISaveDirectChannelParams} channel - The direct channel parameters
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The created channel or error
+     */
+    saveDirectChannel(channel: ISaveDirectChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
 
-    saveChannel(data: ISaveChannelParams): Promise<IChannel | Error>;
+    /**
+     * Creates and saves a team-based channel
+     * 
+     * @param {ISaveChannelParams} data - The channel creation parameters
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The created channel or error
+     */
+    saveChannel(data: ISaveChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
 
-    savePublicChannel(data: ISavePublicChannelParams): Promise<IChannel | Error>;
+    /**
+     * Creates and saves a public channel
+     * 
+     * @param {ISavePublicChannelParams} data - The public channel parameters
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The created channel or error
+     */
+    savePublicChannel(data: ISavePublicChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
 
+    /**
+     * Retrieves unread message information for a user in a channel
+     * 
+     * @param {string} channelId - The ID of the channel
+     * @param {string} userId - The ID of the user
+     * @returns {Promise<IChannelUnread | Error>} - Unread information or error
+     */
     getChannelUnread(channelId: string, userId: string): Promise<IChannelUnread | Error>;
 
+    /**
+     * Invalidates cached channel data by name
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string} name - The name of the channel
+     * @returns {Promise<void>} - Void promise when complete
+     */
     invalidateChannelByName(teamId: string, name: string): Promise<void>;
 
+    /**
+     * Retrieves all pinned posts from a channel
+     * 
+     * @param {string} channelId - The ID of the channel
+     * @returns {Promise<IPost[] | Error>} - Array of pinned posts or error
+     */
     getPinnedPosts(channelId: string): Promise<IPost[] | Error>;
 
-    getFromMaster(id: string): Promise<IChannel | Error>;
+    /**
+     * Retrieves a channel from the master database
+     * 
+     * @param {string} id - The ID of the channel
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The channel or error
+     */
+    getFromMaster(id: string): Promise<AsDomainType<IChannelModel> | Error>;
 
-    restore(channelId: string, time: Date);
+    /**
+     * Restores a previously deleted channel
+     * 
+     * @param {string} channelId - The ID of the channel to restore
+     * @param {Date} time - The restoration timestamp
+     * @returns {Promise<void>} - Void promise when complete
+     */
+    restore(channelId: string, time: Date): Promise<void>;
 
     /**
-     * @description remove all channels for the given team from the database.
-     * @param teamId
+     * Permanently removes all channels for a given team
+     * 
+     * @description Removes all channels associated with a team from the database.
+     * This operation cannot be undone.
+     * 
+     * @param {string} teamId - The ID of the team
+     * @returns {Promise<void | Error>} - Void promise or error
      */
-    permanentDeleteByTeam(teamId: string): void | Error;
+    permanentDeleteByTeam(teamId: string): Promise<void | Error>;
 
     /**
-     * @description removes the given channel
-     * @param channelId
+     * Permanently removes a specific channel
+     * 
+     * @description Completely removes the channel from the database.
+     * This operation cannot be undone.
+     * 
+     * @param {string} channelId - The ID of the channel to delete
+     * @returns {Promise<void | Error>} - Void promise or error
      */
-    permanentDelete(channelId: string): void | Error;
+    permanentDelete(channelId: string): Promise<void | Error>;
 
-    permanentDeleteMembersByChannel(channelId: string): void | Error;
+    /**
+     * Permanently removes all members from a channel
+     * 
+     * @param {string} channelId - The ID of the channel
+     * @returns {Promise<void | Error>} - Void promise or error
+     */
+    permanentDeleteMembersByChannel(channelId: string): Promise<void | Error>;
 
+    /**
+     * Retrieves channels for a team with filtering options
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string} userId - The ID of the user
+     * @param {boolean} includeDeleted - Whether to include deleted channels
+     * @param {number} lastDeleteAt - Timestamp filter for deletions
+     * @param {string} orgId - The organization ID
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of channels or error
+     */
     getChannels(
         teamId: string,
         userId: string,
         includeDeleted: boolean,
         lastDeleteAt: number,
         orgId: string,
-    ): Promise<IChannel[] | Error>;
+    ): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
-    getMoreChannels(teamId: string, userId: string, offset: number, limit: number): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves additional channels with pagination
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string} userId - The ID of the user
+     * @param {number} offset - Number of items to skip
+     * @param {number} limit - Maximum number of items to return
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of channels or error
+     */
+    getMoreChannels(teamId: string, userId: string, offset: number, limit: number): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
-    getPrivateChannelsForTeam(teamId: string, offset: number, limit: number): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves private channels for a team with pagination
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {number} offset - Number of items to skip
+     * @param {number} limit - Maximum number of items to return
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of private channels or error
+     */
+    getPrivateChannelsForTeam(teamId: string, offset: number, limit: number): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
-    getPublicChannelsForTeam(teamId: string, offset: number, limit: number): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves public channels for a team with pagination
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {number} offset - Number of items to skip
+     * @param {number} limit - Maximum number of items to return
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of public channels or error
+     */
+    getPublicChannelsForTeam(teamId: string, offset: number, limit: number): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
-    getPublicChannelsByIdsForTeam(teamId: string, channelsIds: string[]): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves specific public channels by their IDs
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string[]} channelsIds - Array of channel IDs to retrieve
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of channels or error
+     */
+    getPublicChannelsByIdsForTeam(teamId: string, channelsIds: string[]): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
+    /**
+     * Retrieves channel count statistics for a team
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string} userId - The ID of the user
+     * @returns {Promise<any | Error>} - Channel count data or error
+     */
     getChannelCounts(teamId: string, userId: string): Promise<any | Error>;
 
-    getTeamChannels(teamId: string): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves all channels belonging to a team
+     * 
+     * @param {string} teamId - The ID of the team
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of team channels or error
+     */
+    getTeamChannels(teamId: string): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
-    // getByName(teamId: string, name: string): Promise<IChannel | Error>;
-    getByName(name: string): Promise<IChannel>;
+    /**
+     * Retrieves a channel by its name
+     * 
+     * @param {string} name - The name of the channel
+     * @returns {Promise<AsDomainType<IChannelModel> | null>} - The channel or null if not found
+     */
+    getByName(name: string): Promise<AsDomainType<IChannelModel> | null>;
 
-    getByNames(teamId: string, names: string[]): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves multiple channels by their names
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string[]} names - Array of channel names
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of channels or error
+     */
+    getByNames(teamId: string, names: string[]): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
-    getByNameIncludeDeleted(teamId: string, name: string): Promise<IChannel | Error>;
+    /**
+     * Retrieves a channel by name including deleted channels
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string} name - The name of the channel
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The channel or error
+     */
+    getByNameIncludeDeleted(teamId: string, name: string): Promise<AsDomainType<IChannelModel> | Error>;
 
-    getDeletedByName(teamId: string, name: string): Promise<IChannel | Error>;
+    /**
+     * Retrieves a deleted channel by name
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {string} name - The name of the deleted channel
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The deleted channel or error
+     */
+    getDeletedByName(teamId: string, name: string): Promise<AsDomainType<IChannelModel> | Error>;
 
-    getDeleted(teamId: string, offset: number, limit: number, userId: string): Promise<IChannel[] | Error>;
+    /**
+     * Retrieves deleted channels with pagination
+     * 
+     * @param {string} teamId - The ID of the team
+     * @param {number} offset - Number of items to skip
+     * @param {number} limit - Maximum number of items to return
+     * @param {string} userId - The ID of the user
+     * @returns {Promise<Array<AsDomainType<IChannelModel>> | Error>} - Array of deleted channels or error
+     */
+    getDeleted(teamId: string, offset: number, limit: number, userId: string): Promise<Array<AsDomainType<IChannelModel>> | Error>;
 
+    /**
+     * Saves multiple members to the system
+     * 
+     * @param {IUserAccount[]} members - Array of user accounts to save
+     * @returns {Promise<IUserAccount[] | Error>} - Array of saved user accounts or error
+     */
     saveMultipleMembers(members: IUserAccount[]): Promise<IUserAccount[] | Error>;
 
+    /**
+     * Hides a channel from the user's view
+     * 
+     * @param {string} id - The ID of the channel to hide
+     * @returns {Promise<boolean>} - True if successful
+     */
     hideChannel(id: string): Promise<boolean>;
 
+    /**
+     * Removes the current user from a channel
+     * 
+     * @param {string} id - The ID of the channel to leave
+     * @returns {Promise<boolean>} - True if successful
+     */
     leaveChannel(id: string): Promise<boolean>;
 
+    /**
+     * Soft deletes a channel (marks as deleted)
+     * 
+     * @param {string} id - The ID of the channel to delete
+     * @returns {Promise<boolean | Error>} - True if successful or error
+     */
     deleteChannel(id: string): Promise<boolean | Error>;
 
+    /**
+     * Marks a channel as viewed by a user
+     * 
+     * @param {string} id - The ID of the channel
+     * @param {string} user - The ID of the user
+     * @returns {Promise<boolean>} - True if successful
+     */
     viewChannel(id: string, user: string): Promise<boolean>;
+
+    /**
+     * Creates a channel with a project ID
+     * 
+     * @param {string} projectId - The ID of the project
+     * @param {string} value - The value of the channel
+     * @returns {Promise<boolean>} - True if successful
+     */
+    createChannelWithProjectId(projectId: string, channelInput: IChannelInput): Promise<boolean>;
+
+    /**
+     * Disposes of resources used by the service
+     */
+    dispose(): void;
 }

package/lib/templates/services/ExtendedTokenAccountService.ts.template

@@ -1,13 +1,108 @@
-import { IPostThread, IUserAccount,IAccountServiceContext } from 'common';
-import { IBaseService } from '@common-stack/store-mongo';
+/**
+ * Extended Token Account Service Interface
+ * ----------------------------------------
+ * 
+ * This interface defines the business logic layer for token-based account management
+ * within the messenger platform. It provides a comprehensive set of operations for
+ * managing user authentication, device tokens, and push notification capabilities.
+ * 
+ * Key capabilities:
+ * - Device token lifecycle management (registration, updates, removal)
+ * - Auth0 integration for external authentication
+ * - Push notification token management
+ * - Cross-platform device coordination
+ * - Account resolution by authentication providers
+ * - Token-based notification delivery
+ * - Multi-device user session handling
+ * - Secure token storage and validation
+ * 
+ * The service layer abstracts the underlying token management operations and
+ * provides a cohesive API for authentication-related functionality throughout
+ * the messaging platform, handling complex token flows and cross-cutting concerns.
+ */
+
+import {IBaseService, IAccountServiceContext, IUserAccountModel, Disposable, AsDomainType } from 'common/server';
+
 
 //export type IExtendedTokenAccountService = IBaseService<IUserAccount>;
 
-export interface IExtendedTokenAccountService extends IBaseService<IUserAccount> {
-    getDeviceToken(accountId: string): Promise<any>;
-    setDeviceToken(deviceToken: string, accountId: string): Promise<any>;
-    removeDeviceToken(deviceToken: string, accountId: string): Promise<any>;
-    getAccountByAuth0Id(auth0Id: string, context?: IAccountServiceContext): Promise<any>;
-    removeUserExpoTokenByAuth0Id(auth0Id: string, context?: IAccountServiceContext): Promise<any>;
-    
+/**
+ * Extended Token Account Service Interface
+ * 
+ * @description Provides enhanced account management capabilities with focus on
+ * token operations, device management, and authentication integration across
+ * multiple platforms and providers.
+ */
+export interface IExtendedTokenAccountService extends IBaseService<IUserAccountModel>, Disposable {
+    /**
+     * Retrieves device tokens associated with a user account
+     * 
+     * @description Fetches all registered device tokens for push notifications
+     * and real-time messaging delivery. Used for managing notification routing
+     * and device-specific message delivery.
+     * 
+     * @param {string} accountId - The unique identifier of the user account
+     * @returns {Promise<AsDomainType<IUserAccountModel> | Error>} - Device token data or error
+     */
+    getDeviceToken(accountId: string): Promise<AsDomainType<IUserAccountModel> | Error>;
+
+    /**
+     * Registers or updates a device token for an account
+     * 
+     * @description Associates a new device token with the user account for
+     * push notification delivery. Handles token updates, duplicates, and ensures
+     * proper device registration for notification routing.
+     * 
+     * @param {string} deviceToken - The device-specific push notification token
+     * @param {string} accountId - The unique identifier of the user account
+     * @returns {Promise<AsDomainType<IUserAccountModel> | Error>} - Operation result or error
+     */
+    setDeviceToken(deviceToken: string, accountId: string): Promise<AsDomainType<IUserAccountModel> | Error>;
+
+    /**
+     * Removes a specific device token from an account
+     * 
+     * @description Unregisters a device token from push notification delivery.
+     * Typically called during device logout, app uninstallation, or token
+     * rotation scenarios to maintain clean device registration.
+     * 
+     * @param {string} deviceToken - The device token to remove
+     * @param {string} accountId - The unique identifier of the user account
+     * @returns {Promise<AsDomainType<IUserAccountModel> | Error>} - Operation result or error
+     */
+    removeDeviceToken(deviceToken: string, accountId: string): Promise<AsDomainType<IUserAccountModel> | Error>;
+
+    /**
+     * Retrieves a user account by Auth0 authentication ID
+     * 
+     * @description Resolves user account information using external Auth0
+     * authentication provider identifiers. Essential for SSO flows, federated
+     * login scenarios, and maintaining consistent user identity across auth providers.
+     * 
+     * @param {string} auth0Id - The Auth0 user identifier
+     * @param {IAccountServiceContext} [context] - Optional service context for scoped operations
+     * @returns {Promise<AsDomainType<IUserAccountModel> | Error>} - User account or error
+     */
+    getAccountByAuth0Id(auth0Id: string, context?: IAccountServiceContext): Promise<AsDomainType<IUserAccountModel> | Error>;
+
+    /**
+     * Removes Expo push notification tokens by Auth0 ID
+     * 
+     * @description Cleans up all Expo-specific push notification tokens
+     * associated with an Auth0 user. Critical for maintaining token hygiene
+     * during account deletion, logout, or platform migration scenarios.
+     * 
+     * @param {string} auth0Id - The Auth0 user identifier
+     * @param {IAccountServiceContext} [context] - Optional service context for scoped operations
+     * @returns {Promise<void | Error>} - Void promise or error
+     */
+    removeUserExpoTokenByAuth0Id(auth0Id: string, context?: IAccountServiceContext): Promise<void | Error>;
+
+    /**
+     * Disposes of resources used by the service
+     * 
+     * @description Properly cleans up any resources, connections, or subscriptions
+     * maintained by the service instance.
+     */
+    dispose(): void;
 }