Class: PersSDK

import { PersSDK } from '@explorins/pers-sdk';
import { BrowserFetchClientAdapter } from '@explorins/pers-sdk/platform-adapters';

const sdk = new PersSDK(new BrowserFetchClientAdapter(), {
  environment: 'production',
  apiProjectKey: 'your-project-key'
});

// Login with external JWT
await sdk.auth.loginWithToken(firebaseJWT, 'user');

// Check authentication
if (await sdk.auth.isAuthenticated()) {
  const user = await sdk.auth.getCurrentUser();
  console.log('Welcome,', user.name);
}

// Get active businesses
const businesses = await sdk.businesses.getActiveBusinesses();

// Get business details
const business = await sdk.businesses.getBusinessById(businessId);

// Get user's token balances
const tokens = await sdk.tokens.getTokens();

// Get active credit token
const creditToken = await sdk.tokens.getActiveCreditToken();

const unsubscribe = sdk.events.subscribe((event) => {
  // userMessage is always present and UI-ready
  showNotification(event.userMessage, event.level);
});

// Later: cleanup
unsubscribe();

sdk.events.subscribe((event) => {
  if (event.level === 'success' && event.domain === 'transaction') {
    playSuccessSound();
    confetti();
  }
  
  if (event.level === 'error') {
    logToSentry(event);
  }
});

// Auto-unsubscribe after first event
sdk.events.once((event) => {
  console.log('First event received:', event.type);
});

// Login with external JWT (Firebase, Auth0, etc.)
await sdk.auth.loginWithToken(firebaseJWT, 'user');

// Check authentication status
if (await sdk.auth.isAuthenticated()) {
  const user = await sdk.auth.getCurrentUser();
  console.log('Welcome,', user.name);
}

// Logout
await sdk.auth.clearAuth();

// Admin login
await sdk.auth.loginAdmin(adminJWT);

// Check if valid auth exists (synchronous)
if (sdk.auth.hasValidAuth()) {
  console.log('Authentication tokens found');
}

const user = await sdk.user.getCurrentUser();
await sdk.user.updateCurrentUser(userData);
const users = await sdk.user.getAllUsersPublic();

const statusTypes = await sdk.userStatus.getUserStatusTypes();
const earnedStatus = await sdk.userStatus.getEarnedUserStatus();
await sdk.userStatus.createUserStatusType(statusData);

const tokens = await sdk.tokens.getTokens();
const creditToken = await sdk.tokens.getActiveCreditToken();
const rewards = await sdk.tokens.getRewardTokens();

const businesses = await sdk.business.getActiveBusinesses();
const business = await sdk.business.getBusinessById(id);
const types = await sdk.business.getBusinessTypes();

const campaigns = await sdk.campaigns.getActiveCampaigns();
await sdk.campaigns.claimCampaign(claimData);
const claims = await sdk.campaigns.getUserClaims();

const redemptions = await sdk.redemptions.getActiveRedemptions();
await sdk.redemptions.redeem(redemptionId);
const history = await sdk.redemptions.getUserRedemptions();

const transaction = await sdk.transactions.getTransactionById(id);
await sdk.transactions.createTransaction(txData);
const history = await sdk.transactions.getUserTransactionHistory('all');

const intent = await sdk.purchases.createPaymentIntent(100, 'usd', 'email@example.com', 'Purchase');
const tokens = await sdk.purchases.getActivePurchaseTokens();
const purchases = await sdk.purchases.getAllUserPurchases();

const uploadUrl = await sdk.files.getSignedPutUrl('entity-123', 'token', 'jpg');
const accessUrl = await sdk.files.getSignedGetUrl('entity-123', 'token');
const optimizedUrl = await sdk.files.optimizeMedia(originalUrl, 800, 600);

const tenant = await sdk.tenant.getTenantInfo();
const config = await sdk.tenant.getClientConfig();
const admins = await sdk.tenant.getAdmins();

// Create a JWT token for frontend authentication
const jwtToken = await sdk.apiKeys.createJwtToken('Frontend App');
console.log('Store this JWT securely:', jwtToken.key);

// List all API keys
const apiKeys = await sdk.apiKeys.listApiKeys();

// Revoke an old API key
await sdk.apiKeys.revokeApiKey('old-key-id');

const analytics = await sdk.analytics.getTransactionAnalytics(request);

const types = await sdk.donations.getDonationTypes();

// Create a QR code trigger source
const qrSource = await sdk.triggerSources.create({
  name: 'Store Entrance QR',
  type: 'QR_CODE',
  description: 'QR code at main entrance'
});

// Get all trigger sources
const sources = await sdk.triggerSources.getAll();

// Update trigger source
await sdk.triggerSources.update(sourceId, { name: 'Updated Name' });

// Assign to campaign (via campaigns manager)
await sdk.campaigns.assignTriggerSource(campaignId, qrSource.id);

// Admin: Create a webhook
const webhook = await sdk.webhooks.create({
  name: 'Order Processing',
  targetUrl: 'https://n8n.example.com/webhook/orders',
  method: 'POST'
});

// Trigger webhook with payload
const result = await sdk.webhooks.trigger(webhook.id, {
  orderId: 'order-123',
  action: 'created'
});

// Trigger and wait for async workflow completion
const asyncResult = await sdk.webhooks.triggerAndWait(
  'ai-webhook',
  { prompt: 'Analyze this data' },
  30000  // Wait up to 30s
);

// List all custom fields
const fields = await sdk.customFields.getDefinitions();

// Create a new field
const field = await sdk.customFields.createDefinition({
  key: 'employee_id',
  label: 'Employee ID',
  fieldType: 'text',
  validation: { required: true }
});

// Validate user data
const errors = sdk.customFields.validateUserData(formData, fields.data);

// Get all bookings for a user
const bookings = await sdk.bookings.getByUser('user-123');

// Filter by status
const activeBookings = await sdk.bookings.getAll({ status: 'active' });

const booking = await sdk.bookings.create({
  userId: 'user-123',
  locationName: 'Grand Hotel',
  checkInDate: '2026-06-01',
  checkOutDate: '2026-06-05'
});

const hasBooking = await sdk.bookings.hasValidBooking('user-123');
if (hasBooking) {
  // User is eligible for booking-required redemption
}

// Configure SDK with events URL
sdk.configureWalletEvents({ wsUrl: 'wss://events.pers.ninja' });

// Connect after authentication
await sdk.auth.loginWithToken(jwt, 'user');
await sdk.walletEvents.connect();

// Listen for token transfers
sdk.walletEvents.on('Transfer', (event) => {
  if (event.data.to === myWallet) {
    showNotification(`Received ${event.data.value} tokens!`);
  }
});

// Wallet events also flow through sdk.events
sdk.events.subscribe((event) => {
  if (event.domain === 'wallet') {
    console.log('Wallet event:', event.type);
  }
});

await sdk.notifications.connectRealtime();

const inbox = await sdk.notifications.list({ unreadOnly: true });
const { count } = await sdk.notifications.getUnreadCount();

sdk.notifications.onPending(() => {
  // Signal carries no content — re-fetch the inbox
  sdk.notifications.list();
});

import { BrowserFetchClientAdapter } from '@explorins/pers-sdk/platform-adapters';

const sdk = new PersSDK(new BrowserFetchClientAdapter(), {
  environment: 'production',
  apiProjectKey: 'your-project-key'
});

import { NodeHttpClientAdapter } from '@explorins/pers-sdk/platform-adapters';

const sdk = new PersSDK(new NodeHttpClientAdapter(), {
  environment: 'production',
  apiProjectKey: 'your-project-key',
  baseUrl: 'https://api.yourpers.com'
});

import { AngularHttpClientAdapter } from '@explorins/pers-sdk/platform-adapters';

constructor(private http: HttpClient) {
  this.sdk = new PersSDK(new AngularHttpClientAdapter(this.http), {
    environment: 'production',
    apiProjectKey: 'your-project-key'
  });
}

await sdk.connectWalletEvents();

// Manual restore (only needed if autoRestoreSession: false)
const user = await sdk.restoreSession();
if (user) {
  console.log('Welcome back,', user.name);
}

sdk.setDataSource({
  medium: 'email',
  campaign: 'summer_2026',
  source: 'mailchimp',
});

sdk.setDataSource({
  channel: 'mobile',
  medium: 'push',
  campaign: 'retention_30d',
});

sdk.updateDataSource({ campaign: 'new_campaign' });

sdk.setPlatform({
  os: 'iOS',
  osVersion: '17.4',
  app: 'MyApp',
  appVersion: '2.3.1',
  deviceType: 'phone',
});

const apiClient = sdk.api();
const customData = await apiClient.get<CustomType>('/custom-endpoint');
await apiClient.post('/custom-endpoint', customData);