@explorins/pers-sdk 1.0.0-alpha.1 → 1.1.2

package/src/transaction/api/transaction-api.ts

@@ -0,0 +1,296 @@
+import { PersApiClient } from '../../core/pers-api-client';
+import { 
+  TransactionDTO, 
+  TransactionRequestDTO, 
+  ClientTransactionRequestDTO, 
+  ClientTransactionRequestResponseDto,
+  AccountSelectorDTO
+} from '../../shared/interfaces/pers-shared-lib.interfaces';
+import { TransactionPaginationParams, TransactionPaginationResponse, UserBurnTokenRequestDTO } from '../models';
+
+/**
+ * Platform-Agnostic Transaction API Client (UPDATED FOR NEW RESTful ENDPOINTS)
+ * 
+ * Handles transaction operations using the PERS backend.
+ * Uses @explorins/pers-shared DTOs for consistency with backend.
+ * 
+ * MIGRATION NOTES:
+ * - All endpoints changed from /transaction to /transactions
+ * - Role-based paths removed (no more /auth, /admin, /business in URLs)
+ * - New RESTful resource-based structure
+ * - Added new client-side transaction flow methods
+ * - Enhanced admin query capabilities
+ */
+export class TransactionApi {
+  constructor(private apiClient: PersApiClient) {}
+
+  private readonly basePath = '/transactions';
+
+  /**
+   * Get transaction by ID (public endpoint)
+   * 
+   * UPDATED: /transaction/{id} → /transactions/{id}
+   */
+  async getTransactionById(transactionId: string): Promise<TransactionDTO> {
+    return this.apiClient.get<TransactionDTO>(`${this.basePath}/${transactionId}`);
+  }
+
+  // ==========================================
+  // AUTHENTICATED USER OPERATIONS
+  // ==========================================
+
+  /**
+   * AUTH: Create authenticated user transaction
+   * 
+   * UPDATED: /transaction/auth/transaction → /transactions/user
+   */
+  async createAuthTransaction(request: TransactionRequestDTO): Promise<TransactionDTO> {
+    return this.apiClient.post<TransactionDTO>(`${this.basePath}/user`, request);
+  }
+
+  /**
+   * AUTH: Get user's sent transactions
+   * 
+   * UPDATED: /transaction/auth/sender → /transactions/me/sent
+   */
+  async getUserSentTransactions(): Promise<TransactionDTO[]> {
+    const params = new URLSearchParams({
+      timestamp: Date.now().toString()
+    });
+
+    return this.apiClient.get<TransactionDTO[]>(`${this.basePath}/me/sent?${params.toString()}`);
+  }
+
+  /**
+   * AUTH: Get user's received transactions
+   * 
+   * UPDATED: /transaction/auth/recipient → /transactions/me/received
+   */
+  async getUserReceivedTransactions(): Promise<TransactionDTO[]> {
+    const params = new URLSearchParams({
+      timestamp: Date.now().toString()
+    });
+
+    return this.apiClient.get<TransactionDTO[]>(`${this.basePath}/me/received?${params.toString()}`);
+  }
+
+  /**
+   * AUTH: Get user transaction history by type (backwards compatibility)
+   * 
+   * UPDATED: Maps to appropriate /transactions/me/* endpoints
+   */
+  async getUserTransactionHistory(type: string): Promise<TransactionDTO[]> {
+    const params = new URLSearchParams({
+      timestamp: Date.now().toString()
+    });
+    
+    // Map legacy type parameter to new endpoints
+    switch (type.toLowerCase()) {
+      case 'sender':
+      case 'sent':
+        return this.apiClient.get<TransactionDTO[]>(`${this.basePath}/me/sent?${params.toString()}`);
+      case 'recipient':
+      case 'received':
+        return this.apiClient.get<TransactionDTO[]>(`${this.basePath}/me/received?${params.toString()}`);
+      default:
+        // Default to sent transactions for backwards compatibility
+        return this.apiClient.get<TransactionDTO[]>(`${this.basePath}/me/sent?${params.toString()}`);
+    }
+  }
+
+  /**
+   * AUTH: Prepare client signed transaction
+   * 
+   * UPDATED: /transaction/auth/prepare-signing → /transactions/prepare
+   */
+  async prepareClientSignedTransaction(request: ClientTransactionRequestDTO): Promise<ClientTransactionRequestResponseDto> {
+    return this.apiClient.post<ClientTransactionRequestResponseDto>(`${this.basePath}/prepare`, request);
+  }
+
+  /**
+   * AUTH: Prepare existing transaction for client-side signing
+   * 
+   * NEW ENDPOINT: GET /transactions/{id}/prepare
+   */
+  async prepareExistingTransaction(transactionId: string): Promise<ClientTransactionRequestResponseDto> {
+    return this.apiClient.get<ClientTransactionRequestResponseDto>(`${this.basePath}/${transactionId}/prepare`);
+  }
+
+  /**
+   * AUTH: Submit client-side signed transaction
+   * 
+   * NEW ENDPOINT: POST /transactions/{id}/submit
+   */
+  async submitSignedTransaction(transactionId: string, signedData: any): Promise<TransactionDTO> {
+    return this.apiClient.post<TransactionDTO>(`${this.basePath}/${transactionId}/submit`, signedData);
+  }
+
+  /**
+   * AUTH: Burn user tokens
+   * 
+   * UPDATED: Uses new user transaction endpoint with burn-specific parameters
+   * Note: This might need backend confirmation on burn functionality implementation
+   */
+  async burnUserTokens(request: UserBurnTokenRequestDTO): Promise<TransactionDTO> {
+    // Map burn request to TransactionRequestDTO format for new endpoint
+    const transactionRequest: TransactionRequestDTO = {
+      ...request,
+      // Add any specific burn transaction parameters here
+    } as any;
+
+    return this.apiClient.post<TransactionDTO>(`${this.basePath}/user`, transactionRequest);
+  }
+
+  // ==========================================
+  // BUSINESS OPERATIONS
+  // ==========================================
+
+  /**
+   * BUSINESS: Create business transaction
+   * 
+   * UPDATED: /transaction/business/transaction → /transactions/business
+   */
+  async createBusinessTransaction(request: TransactionRequestDTO): Promise<TransactionDTO> {
+    return this.apiClient.post<TransactionDTO>(`${this.basePath}/business`, request);
+  }
+
+  // ==========================================
+  // ADMIN OPERATIONS
+  // ==========================================
+
+  /**
+   * ADMIN: Create admin transaction
+   * 
+   * UPDATED: /transaction/admin/transaction → /transactions/admin
+   */
+  async createAdminTransaction(request: TransactionRequestDTO): Promise<TransactionDTO> {
+    return this.apiClient.post<TransactionDTO>(`${this.basePath}/system`, request);
+  }
+
+  /**
+   * ADMIN: Get all tenant transactions
+   * 
+   * UPDATED: /transaction/admin → /transactions
+   */
+  async getTenantTransactions(): Promise<TransactionDTO[]> {
+    const result = await this.apiClient.get<TransactionPaginationResponse>(`${this.basePath}`);
+    // If the new endpoint returns paginated response, extract the data array
+    if ('data' in result) {
+      return result.data;
+    }
+    // Fallback for direct array response
+    return result as any as TransactionDTO[];
+  }
+
+  /**
+   * ADMIN: Get paginated transactions with filtering and sorting
+   * 
+   * UPDATED: /transaction/admin → /transactions (same endpoint, better structure)
+   */
+  async getPaginatedTransactions(params: TransactionPaginationParams): Promise<TransactionPaginationResponse> {
+    // Build query parameters
+    const queryParams: Record<string, string> = {
+      page: params.page.toString(),
+      limit: params.limit.toString()
+    };
+
+    // Add sorting parameters if provided
+    if (params.sortBy) {
+      queryParams['sortBy'] = params.sortBy;
+    }
+    if (params.sortOrder) {
+      queryParams['sortOrder'] = params.sortOrder;
+    }
+
+    // Add user-specific filtering if provided
+    if (params.participantId) {
+      queryParams['participantId'] = params.participantId;
+    }
+
+    // Add status filtering if provided
+    if (params.status) {
+      queryParams['status'] = params.status;
+    }
+
+    // Add additional filters if provided
+    if (params.filters) {
+      if (params.filters.startDate) {
+        queryParams['startDate'] = params.filters.startDate;
+      }
+      if (params.filters.endDate) {
+        queryParams['endDate'] = params.filters.endDate;
+      }
+      if (params.filters.type && params.filters.type.length > 0) {
+        queryParams['type'] = params.filters.type.join(',');
+      }
+      if (params.filters.tokenType && params.filters.tokenType.length > 0) {
+        queryParams['tokenType'] = params.filters.tokenType.join(',');
+      }
+    }
+
+    // Build query string
+    const queryString = Object.entries(queryParams)
+      .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+      .join('&');
+
+    return this.apiClient.get<TransactionPaginationResponse>(`${this.basePath}?${queryString}`);
+  }
+
+  /**
+   * ADMIN: Export transactions to CSV
+   * 
+   * UPDATED: /transaction/admin/export/csv → /transactions/export/csv
+   */
+  async exportTransactionsCSV(): Promise<Blob> {
+    return this.apiClient.get<Blob>(`${this.basePath}/export/csv`, 'blob');
+  }
+
+  // ==========================================
+  // NEW ADMIN QUERY METHODS
+  // ==========================================
+
+  /**
+   * ADMIN: Query transactions by sender
+   * 
+   * NEW ENDPOINT: POST /transactions/query-sender
+   */
+  async queryTransactionsBySender(accountSelector: AccountSelectorDTO): Promise<TransactionDTO[]> {
+    return this.apiClient.post<TransactionDTO[]>(`${this.basePath}/query-sender`, accountSelector);
+  }
+
+  /**
+   * ADMIN: Query transactions by recipient
+   * 
+   * NEW ENDPOINT: POST /transactions/query-recipient
+   */
+  async queryTransactionsByRecipient(accountSelector: AccountSelectorDTO): Promise<TransactionDTO[]> {
+    return this.apiClient.post<TransactionDTO[]>(`${this.basePath}/query-recipient`, accountSelector);
+  }
+
+  /**
+   * ADMIN: Get transaction analytics
+   * 
+   * NEW ENDPOINT: POST /transactions/analytics
+   */
+  async getTransactionAnalytics(analyticsRequest: any): Promise<any> {
+    return this.apiClient.post<any>(`${this.basePath}/analytics`, analyticsRequest);
+  }
+
+  // ==========================================
+  // CONVENIENCE METHODS (BACKWARDS COMPATIBILITY)
+  // ==========================================
+
+  /**
+   * Convenience method: Get user sent transactions (alias)
+   */
+  async getUserSenderTransactions(): Promise<TransactionDTO[]> {
+    return this.getUserSentTransactions();
+  }
+
+  /**
+   * Convenience method: Get user received transactions (alias)
+   */
+  async getUserRecipientTransactions(): Promise<TransactionDTO[]> {
+    return this.getUserReceivedTransactions();
+  }
+}

package/src/transaction/index.ts

@@ -0,0 +1,65 @@
+/**
+ * @explorins/pers-sdk-transaction
+ * 
+ * Platform-agnostic Transaction Domain SDK for PERS ecosystem
+ * Handles transaction operations across different authorization levels
+ */
+
+// API Layer
+export { TransactionApi } from './api/transaction-api';
+
+// Service Layer  
+export { TransactionService } from './services/transaction-service';
+
+// Models & Types
+export * from './models';
+export * from '../shared/interfaces/pers-shared-lib.interfaces';
+
+// Models & Types
+export * from './models';
+
+import { ClientTransactionRequestDTO, TransactionRequestDTO } from '../shared/interfaces/pers-shared-lib.interfaces';
+// Factory function for creating transaction SDK instance
+import { PersApiClient } from '../core/pers-api-client';
+import { TransactionApi } from './api/transaction-api';
+import { TransactionService } from './services/transaction-service';
+import { TransactionPaginationParams, UserBurnTokenRequestDTO } from './models';
+
+/**
+ * Create a complete Transaction SDK instance
+ * 
+ * @param apiClient - Configured PERS API client
+ * @returns Transaction SDK with flattened structure for better DX
+ */
+export function createTransactionSDK(apiClient: PersApiClient) {
+  const transactionApi = new TransactionApi(apiClient);
+  const transactionService = new TransactionService(transactionApi);
+  
+  return {
+    // Direct access to service methods (primary interface)
+    
+    // Public methods
+    getTransactionById: (transactionId: string) => transactionService.getTransactionById(transactionId),
+    
+    // Auth methods
+    createAuthTransaction: (request: TransactionRequestDTO) => transactionService.createAuthTransaction(request),
+    getUserTransactionHistory: (type: string) => transactionService.getUserTransactionHistory(type),
+    prepareClientSignedTransaction: (request: ClientTransactionRequestDTO) => transactionService.prepareClientSignedTransaction(request),
+    burnUserTokens: (request: UserBurnTokenRequestDTO) => transactionService.burnUserTokens(request),
+    
+    // Business methods
+    createBusinessTransaction: (request: TransactionRequestDTO) => transactionService.createBusinessTransaction(request),
+    
+    // Admin methods
+    createAdminTransaction: (request: TransactionRequestDTO) => transactionService.createAdminTransaction(request),
+    getTenantTransactions: () => transactionService.getTenantTransactions(),
+    getPaginatedTransactions: (params: TransactionPaginationParams) => transactionService.getPaginatedTransactions(params),
+    exportTransactionsCSV: () => transactionService.exportTransactionsCSV(),
+    
+    // Advanced access for edge cases
+    api: transactionApi,
+    service: transactionService
+  };
+}
+
+export type TransactionSDK = ReturnType<typeof createTransactionSDK>;

package/src/transaction/models/index.ts

@@ -0,0 +1,60 @@
+/**
+ * Transaction Domain Models
+ * 
+ * Re-exports from @explorins/pers-shared for consistency with backend
+ * and to provide a single import source for transaction-related types.
+ */
+
+// Core transaction entities from centralized pers-shared interfaces
+export type {
+  TransactionDTO,
+  TransactionRequestDTO,
+  ClientTransactionRequestDTO,
+  ClientTransactionRequestResponseDto,
+  UserToBusinessTokenTransactionCreateRequestDTO
+} from '../../shared/interfaces/pers-shared-lib.interfaces';
+
+// Import for local interface usage
+import { TransactionDTO } from '../../shared/interfaces/pers-shared-lib.interfaces';
+
+// Local transaction interfaces
+// TODO: Move these to @explorins/pers-shared when standardized across domains
+export interface TransactionPaginationParams {
+  page: number;
+  limit: number;
+  participantId?: string; // User ID for filtering user transactions
+  status?: string;
+  sortBy?: string;      // ✅ ADD: Column to sort by
+  sortOrder?: 'ASC' | 'DESC'; // ✅ ADD: Sort direction
+  filters?: {
+    startDate?: string;
+    endDate?: string;
+    type?: string[];
+    tokenType?: string[];
+  };
+}
+
+export interface TransactionPaginationResponse {
+  data: TransactionDTO[];
+  pagination: {
+    page: string;
+    limit: string;
+    total: number;
+    pages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+  };
+}
+
+export interface UserBurnTokenRequestDTO {
+  tokenAddress: string;
+  tokenMetadataIncrementalId: string;
+  chainId: number;
+  amount: number;
+}
+
+// Transaction account types (domain-specific enum)
+export enum TransactionAccountType {
+  // Add specific transaction account types as needed
+  // This should match the enum used in the infrastructure layer
+}

package/src/transaction/services/transaction-service.ts

@@ -0,0 +1,104 @@
+import { TransactionDTO } from '../../shared/interfaces/pers-shared-lib.interfaces';
+import { TransactionApi } from '../api/transaction-api';
+import { 
+  TransactionRequestDTO,
+  ClientTransactionRequestDTO,
+  ClientTransactionRequestResponseDto,
+  TransactionPaginationParams,
+  TransactionPaginationResponse,
+  UserBurnTokenRequestDTO
+} from '../models';
+
+/**
+ * Platform-Agnostic Transaction Service
+ * 
+ * Contains transaction business logic and operations that work across platforms.
+ * No framework dependencies - pure TypeScript business logic.
+ * 
+ * Focuses only on actual backend capabilities.
+ */
+export class TransactionService {
+  constructor(private transactionApi: TransactionApi) {}
+
+  /**
+   * Get transaction by ID
+   */
+  async getTransactionById(transactionId: string): Promise<TransactionDTO> {
+    return this.transactionApi.getTransactionById(transactionId);
+  }
+
+  // ==========================================
+  // AUTHENTICATED OPERATIONS
+  // ==========================================
+
+  /**
+   * AUTH: Create authenticated transaction
+   */
+  async createAuthTransaction(request: TransactionRequestDTO): Promise<TransactionDTO> {
+    return this.transactionApi.createAuthTransaction(request);
+  }
+
+  /**
+   * AUTH: Get user transaction history by type
+   */
+  async getUserTransactionHistory(type: string): Promise<TransactionDTO[]> {
+    return this.transactionApi.getUserTransactionHistory(type);
+  }
+
+  /**
+   * AUTH: Prepare client signed transaction
+   */
+  async prepareClientSignedTransaction(request: ClientTransactionRequestDTO): Promise<ClientTransactionRequestResponseDto> {
+    return this.transactionApi.prepareClientSignedTransaction(request);
+  }
+
+  /**
+   * AUTH: Burn user tokens
+   */
+  async burnUserTokens(request: UserBurnTokenRequestDTO): Promise<TransactionDTO> {
+    return this.transactionApi.burnUserTokens(request);
+  }
+
+  // ==========================================
+  // BUSINESS OPERATIONS
+  // ==========================================
+
+  /**
+   * BUSINESS: Create business transaction
+   */
+  async createBusinessTransaction(request: TransactionRequestDTO): Promise<TransactionDTO> {
+    return this.transactionApi.createBusinessTransaction(request);
+  }
+
+  // ==========================================
+  // ADMIN OPERATIONS
+  // ==========================================
+
+  /**
+   * ADMIN: Create admin transaction
+   */
+  async createAdminTransaction(request: TransactionRequestDTO): Promise<TransactionDTO> {
+    return this.transactionApi.createAdminTransaction(request);
+  }
+
+  /**
+   * ADMIN: Get all tenant transactions
+   */
+  async getTenantTransactions(): Promise<TransactionDTO[]> {
+    return this.transactionApi.getTenantTransactions();
+  }
+
+  /**
+   * ADMIN: Get paginated transactions with filtering and sorting
+   */
+  async getPaginatedTransactions(params: TransactionPaginationParams): Promise<TransactionPaginationResponse> {
+    return this.transactionApi.getPaginatedTransactions(params);
+  }
+
+  /**
+   * ADMIN: Export transactions to CSV
+   */
+  async exportTransactionsCSV(): Promise<Blob> {
+    return this.transactionApi.exportTransactionsCSV();
+  }
+}

package/src/user/api/user-api.ts

@@ -0,0 +1,98 @@
+import { UserDTO, UserCreateRequestDTO } from '../../shared/interfaces/pers-shared-lib.interfaces';
+import { PersApiClient } from '../../core/pers-api-client';
+import { UserPublicProfileDTO } from '../models';
+
+/**
+ * Platform-Agnostic User API Client
+ * 
+ * Handles user operations using the PERS backend RESTful API.
+ * Updated to use new /users endpoints with enhanced security and consistency.
+ * Maintains framework UserApiService method compatibility.
+ */
+export class UserApi {
+  constructor(private apiClient: PersApiClient) {}
+
+  private readonly basePath = '/users';
+
+  // ==========================================
+  // PUBLIC OPERATIONS
+  // ==========================================
+
+  /**
+   * PUBLIC: Get all users public profiles with optional filtering
+   * ✅ UPDATED: Uses new RESTful /users/public endpoint
+   */
+  async getAllUsersPublicProfiles(filter: {key: string, value: string} | null = null): Promise<UserPublicProfileDTO[]> {
+    let url = `${this.basePath}/public`;
+    
+    if (filter) {
+      // ✅ MAINTAINED: Same parameter pattern for compatibility
+      const params = new URLSearchParams();
+      params.set('filterKey', filter.key);
+      params.set('filterValue', filter.value);
+      url += `?${params.toString()}`;
+    }
+    
+    return this.apiClient.get<UserPublicProfileDTO[]>(url);
+  }
+
+  // ==========================================
+  // AUTHENTICATED OPERATIONS
+  // ==========================================
+
+  /**
+   * AUTH: Get current authenticated user
+   * ✅ UPDATED: Uses new RESTful /users/me endpoint
+   */
+  async getRemoteUser(): Promise<UserDTO> {
+    return this.apiClient.get<UserDTO>(`${this.basePath}/me`);
+  }
+
+  /**
+   * AUTH: Update current authenticated user
+   * ✅ UPDATED: Uses new RESTful /users/me endpoint
+   */
+  async updateRemoteUser(updateRequest: UserCreateRequestDTO): Promise<UserDTO> {
+    return this.apiClient.put<UserDTO>(`${this.basePath}/me`, updateRequest);
+  }
+
+  // ==========================================
+  // ADMIN OPERATIONS
+  // ==========================================
+
+  /**
+   * ADMIN: Get all remote users with query parameters
+   * ✅ UPDATED: Uses new RESTful /users endpoint with role-based access
+   * Note: Admin users get full data, non-admin users get public profiles only
+   */
+  async getAllRemoteUsers(): Promise<UserDTO[]> {
+    // ✅ MAINTAINED: Same merge=soft parameter for compatibility
+    const url = `${this.basePath}?merge=soft`;
+    return this.apiClient.get<UserDTO[]>(url);
+  }
+
+  /**
+   * ADMIN: Update user as admin
+   * ✅ UPDATED: Uses new RESTful /users/{id} endpoint
+   */
+  async updateUserAsAdmin(id: string, userData: UserCreateRequestDTO): Promise<UserDTO> {
+    return this.apiClient.put<UserDTO>(`${this.basePath}/${id}`, userData);
+  }
+
+  /**
+   * ADMIN: Toggle user active status
+   * ✅ UPDATED: Uses new consistent /users/{id}/status endpoint
+   * Enhanced: Follows RESTful status management pattern across all domains
+   */
+  async toggleUserActiveStatusByUser(user: UserDTO): Promise<UserDTO> {
+    return this.apiClient.put<UserDTO>(`${this.basePath}/${user.id}/status`, {});
+  }
+
+  /**
+   * ADMIN: Get user by unique identifier
+   * ✅ UPDATED: Uses new RESTful /users/{id} endpoint
+   */
+  async getUserByUniqueIdentifier(id: string): Promise<UserDTO> {
+    return this.apiClient.get<UserDTO>(`${this.basePath}/${id}`);
+  }
+}

package/src/user/index.ts

@@ -0,0 +1,62 @@
+/**
+ * @explorins/pers-sdk-user
+ * 
+ * Platform-agnostic User Domain SDK for PERS ecosystem
+ * Handles user management, profiles, and authentication operations
+ */
+
+// API Layer
+export { UserApi } from './api/user-api';
+
+// Service Layer  
+export { UserService } from './services/user-service';
+
+// Models & Types
+export * from './models';
+export * from '../shared/interfaces/pers-shared-lib.interfaces';
+
+// Factory function for creating user SDK instance
+import { PersApiClient } from '../core/pers-api-client';
+import { UserApi } from './api/user-api';
+import { UserService } from './services/user-service';
+import { UserDTO, UserCreateRequestDTO } from '../shared/interfaces/pers-shared-lib.interfaces';
+
+/**
+ * Create a complete User SDK instance
+ * 
+ * @param apiClient - Configured PERS API client
+ * @returns User SDK with flattened structure for better DX
+ */
+export function createUserSDK(apiClient: PersApiClient) {
+  const userApi = new UserApi(apiClient);
+  const userService = new UserService(userApi);
+  
+  return {
+    // Direct access to service methods (primary interface)
+    
+    // Public methods - matches framework exactly
+    getAllUsersPublicProfiles: (filter: {key: string, value: string} | null = null) => 
+      userService.getAllUsersPublicProfiles(filter),
+    
+    // Auth methods - matches framework exactly
+    getRemoteUser: () => userService.getRemoteUser(),
+    updateRemoteUser: (updateRequest: UserCreateRequestDTO) => 
+      userService.updateRemoteUser(updateRequest),
+    
+    // Admin methods - matches framework exactly
+    getAllRemoteUsers: () => userService.getAllRemoteUsers(),
+    updateUserAsAdmin: (id: string, userData: UserCreateRequestDTO) => 
+      userService.updateUserAsAdmin(id, userData),
+    toggleUserActiveStatusByUser: (user: UserDTO) => 
+      userService.toggleUserActiveStatusByUser(user),
+
+    getUserByUniqueIdentifier: (id: string) =>
+      userService.getUserByUniqueIdentifier(id),
+    
+    // Advanced access for edge cases
+    api: userApi,
+    service: userService
+  };
+}
+
+export type UserSDK = ReturnType<typeof createUserSDK>;

package/src/user/models/index.ts

@@ -0,0 +1,10 @@
+/**
+ * User Domain Models
+ * 
+ * Local user interfaces - TODO: Move these to @explorins/pers-shared when standardized
+ */
+
+export interface UserPublicProfileDTO {
+  id: string,
+  publicProfile: {[key: string]: any}
+}