getTiers(): Promise<OrganizationTier[]>

const tiers = await sso.platform.getTiers();

tiers.forEach(tier => {
  console.log(`${tier.display_name}: $${tier.price_cents / 100}/mo`);
  console.log(`  Max Services: ${tier.max_services ?? 'Unlimited'}`);
  console.log(`  Max Users: ${tier.max_users ?? 'Unlimited'}`);
});

organizations.list(params?: ListPlatformOrganizationsParams): Promise<PlatformOrganizationsListResponse>

// List all pending organizations
const result = await sso.platform.organizations.list({
  status: 'pending',
  page: 1,
  limit: 50
});

console.log(`${result.total} pending organizations`);
result.organizations.forEach(org => {
  console.log(`- ${org.name} (${org.slug})`);
  console.log(`  Created: ${new Date(org.created_at).toLocaleDateString()}`);
});

// List organizations on a specific tier
const tierOrgs = await sso.platform.organizations.list({
  tier_id: 'tier-pro',
  page: 1,
  limit: 100
});
console.log(`${tierOrgs.total} organizations on Pro tier`);

organizations.approve(orgId: string, payload: ApproveOrganizationPayload): Promise<Organization>

const approved = await sso.platform.organizations.approve('org-id-123', {
  tier_id: 'tier-starter'
});

console.log(` Approved ${approved.name}`);
console.log(`  Status: ${approved.status}`);
console.log(`  Tier: ${approved.tier_id}`);

organizations.reject(orgId: string, payload: RejectOrganizationPayload): Promise<Organization>

await sso.platform.organizations.reject('org-id-123', {
  reason: 'Organization name violates platform terms of service'
});

console.log('Organization rejected');

organizations.suspend(orgId: string): Promise<Organization>

const suspended = await sso.platform.organizations.suspend('org-id-123');

console.log(` Suspended ${suspended.name}`);
console.log(`  Status: ${suspended.status}`);

organizations.activate(orgId: string): Promise<Organization>

const activated = await sso.platform.organizations.activate('org-id-123');

console.log(` Activated ${activated.name}`);
console.log(`  Status: ${activated.status}`);

organizations.updateTier(orgId: string, payload: UpdateOrganizationTierPayload): Promise<Organization>

// Upgrade organization to Pro tier
await sso.platform.organizations.updateTier('org-id-123', {
  tier_id: 'tier-pro'
});

// Apply custom limits (enterprise customer)
await sso.platform.organizations.updateTier('org-id-456', {
  tier_id: 'tier-enterprise',
  max_services: 100,
  max_users: 1000
});

console.log('Organization tier updated');

organizations.delete(orgId: string): Promise<{success: boolean, message: string}>

// WARNING: This is irreversible!
const result = await sso.platform.organizations.delete('org-id-123');

console.log(result.message); // 'Organization deleted successfully'

// Best practice: Confirm with user before deleting
const confirmDelete = confirm(
  `Are you sure you want to permanently delete this organization? This cannot be undone.`
);

if (confirmDelete) {
  await sso.platform.organizations.delete(orgId);
  console.log(' Organization deleted');
}

promoteOwner(payload: PromotePlatformOwnerPayload): Promise<void>

await sso.platform.promoteOwner({
  user_id: 'user-uuid-here'
});

console.log(' User promoted to platform owner');

demoteOwner(userId: string): Promise<void>

await sso.platform.demoteOwner('user-uuid-here');

console.log(' Platform owner demoted to regular user');

users.search(query: string, options?: { limit?: number }): Promise<Array<UserSearchResult>>

// Search by email
const users = await sso.platform.users.search('john@example.com');
console.log(users); // [{ id: 'user-uuid', email: 'john@example.com', ... }]

// Search by partial email
const matches = await sso.platform.users.search('john@', { limit: 5 });
console.log(`Found ${matches.length} users matching 'john@'`);

// Search by user ID
const userById = await sso.platform.users.search('user-uuid-here');
if (userById.length > 0) {
  console.log(`Found user: ${userById[0].email}`);
}

users.getMfaStatus(userId: string): Promise<{enabled: boolean, has_backup_codes: boolean}>

const mfaStatus = await sso.platform.users.getMfaStatus('user-uuid-here');

if (mfaStatus.enabled) {
  console.log(' MFA is enabled for this user');
  console.log(`  Backup codes: ${mfaStatus.has_backup_codes ? 'Yes' : 'No'}`);
} else {
  console.log('MFA is not enabled for this user');
}

users.forceDisableMfa(userId: string): Promise<{success: boolean, message: string}>

// User has lost their authenticator and backup codes
const result = await sso.platform.users.forceDisableMfa('user-uuid-here');

console.log(result.message); // 'MFA disabled successfully'
console.log(' User can now log in without MFA');

// Best practice: Verify user identity before disabling MFA
const mfaStatus = await sso.platform.users.getMfaStatus(userId);
if (mfaStatus.enabled) {
  const confirmed = confirm(
    'Are you sure you want to disable MFA for this user? They should re-enable it after regaining access.'
  );

  if (confirmed) {
    await sso.platform.users.forceDisableMfa(userId);
    console.log(' MFA disabled - user should re-enable ASAP');
  }
}

getAuditLog(params?: GetAuditLogParams): Promise<AuditLogEntry[]>

// Get recent audit logs
const logs = await sso.platform.getAuditLog({
  limit: 100
});

logs.forEach(log => {
  console.log(`[${log.created_at}] ${log.actor_email}: ${log.action}`);
  if (log.metadata) {
    console.log(`  Details:`, log.metadata);
  }
});

// Filter by specific action
const approvals = await sso.platform.getAuditLog({
  action: 'organization.approved',
  start_date: '2024-01-01',
  limit: 50
});

console.log(`${approvals.length} organizations approved since Jan 1, 2024`);

// Track specific organization's history
const orgHistory = await sso.platform.getAuditLog({
  target_type: 'organization',
  target_id: 'org-id-123'
});

console.log(`Audit history for organization:`);
orgHistory.forEach(log => {
  console.log(`  - ${log.action} by ${log.actor_email} on ${log.created_at}`);
});

analytics.getOverview(): Promise<PlatformOverviewMetrics>

const metrics = await sso.platform.analytics.getOverview();

console.log('Platform Overview:');
console.log(`  Organizations: ${metrics.active_organizations}/${metrics.total_organizations}`);
console.log(`  Total Users: ${metrics.total_users}`);
console.log(`  Total Services: ${metrics.total_services}`);
console.log(`  30-Day Activity:`);
console.log(`    - Logins: ${metrics.total_logins_30d}`);
console.log(`    - Active Users: ${metrics.unique_users_30d}`);

// Calculate engagement rate
const engagementRate = (metrics.unique_users_30d / metrics.total_users * 100).toFixed(1);
console.log(`    - Engagement Rate: ${engagementRate}%`);

analytics.getOrganizationStatus(): Promise<OrganizationStatusBreakdown>

const breakdown = await sso.platform.analytics.getOrganizationStatus();

console.log('Organization Status:');
console.log(`  � Pending: ${breakdown.pending}`);
console.log(`   Active: ${breakdown.active}`);
console.log(`  � Suspended: ${breakdown.suspended}`);
console.log(`   Rejected: ${breakdown.rejected}`);

// Alert if pending queue is high
if (breakdown.pending > 10) {
  console.warn(`� ${breakdown.pending} organizations awaiting approval`);
}

analytics.getGrowthTrends(params?: PlatformAnalyticsDateRangeParams): Promise<GrowthTrendPoint[]>

// Get 30-day growth trends
const trends = await sso.platform.analytics.getGrowthTrends({
  start_date: '2024-01-01',
  end_date: '2024-01-31'
});

console.log('Growth Trends (Jan 2024):');
trends.forEach(point => {
  console.log(`${point.date}:`);
  console.log(`  Organizations: ${point.total_organizations} (+${point.new_organizations})`);
  console.log(`  Users: ${point.total_users} (+${point.new_users})`);
});

// Calculate growth rate
const firstDay = trends[0];
const lastDay = trends[trends.length - 1];
const orgGrowth = ((lastDay.total_organizations - firstDay.total_organizations) / firstDay.total_organizations * 100).toFixed(1);
console.log(`\nOrganization growth: ${orgGrowth}%`);

analytics.getLoginActivity(params?: PlatformAnalyticsDateRangeParams): Promise<LoginActivityPoint[]>

// Get 7-day login activity
const activity = await sso.platform.analytics.getLoginActivity({
  start_date: '2024-01-01',
  end_date: '2024-01-07'
});

console.log('Login Activity (Jan 1-7):');
activity.forEach(point => {
  console.log(`${point.date}:`);
  console.log(`  Logins: ${point.total_logins}`);
  console.log(`  Unique Users: ${point.unique_users}`);
  console.log(`  Failed Attempts: ${point.failed_logins}`);

  // Calculate failure rate
  const failureRate = (point.failed_logins / (point.total_logins + point.failed_logins) * 100).toFixed(1);
  console.log(`  Failure Rate: ${failureRate}%`);
});

// Identify peak login days
const peakDay = activity.reduce((max, point) =>
  point.total_logins > max.total_logins ? point : max
);
console.log(`\nPeak day: ${peakDay.date} with ${peakDay.total_logins} logins`);

analytics.getTopOrganizations(): Promise<TopOrganization[]>

const topOrgs = await sso.platform.analytics.getTopOrganizations();

console.log('Top 10 Most Active Organizations (30 days):');
topOrgs.forEach((org, index) => {
  console.log(`${index + 1}. ${org.name} (${org.slug})`);
  console.log(`   Users: ${org.user_count} | Services: ${org.service_count}`);
  console.log(`   Logins: ${org.login_count_30d} (${org.unique_users_30d} unique users)`);

  // Calculate engagement
  const engagement = (org.unique_users_30d / org.user_count * 100).toFixed(1);
  console.log(`   Engagement: ${engagement}%`);
});

analytics.getRecentOrganizations(params?: GetAuditLogParams): Promise<RecentOrganization[]>

// Get 10 most recent organizations
const recent = await sso.platform.analytics.getRecentOrganizations({
  limit: 10
});

console.log('Recently Created Organizations:');
recent.forEach(org => {
  const daysAgo = Math.floor((Date.now() - new Date(org.created_at).getTime()) / (1000 * 60 * 60 * 24));
  console.log(`- ${org.name} (${org.slug})`);
  console.log(`  Status: ${org.status} | Created: ${daysAgo} days ago`);
});

// Count by status
const pending = recent.filter(org => org.status === 'pending').length;
console.log(`\n${pending} awaiting approval`);

import { SsoClient } from '@drmhse/sso-sdk';

const sso = new SsoClient({
  baseURL: 'https://authos.example.com',
  token: localStorage.getItem('sso_access_token')
});

async function displayPlatformDashboard() {
  console.log('=== PLATFORM ADMINISTRATION DASHBOARD ===\n');

  // 1. Platform Overview
  const overview = await sso.platform.analytics.getOverview();
  console.log('PLATFORM OVERVIEW:');
  console.log(`  Total Organizations: ${overview.total_organizations}`);
  console.log(`  Active Organizations: ${overview.active_organizations}`);
  console.log(`  Total Users: ${overview.total_users}`);
  console.log(`  Total Services: ${overview.total_services}`);
  console.log(`  30-Day Logins: ${overview.total_logins_30d}`);
  console.log(`  30-Day Active Users: ${overview.unique_users_30d}`);

  // 2. Organization Status Breakdown
  const status = await sso.platform.analytics.getOrganizationStatus();
  console.log('\nORGANIZATION STATUS:');
  console.log(`  � Pending: ${status.pending}`);
  console.log(`   Active: ${status.active}`);
  console.log(`  � Suspended: ${status.suspended}`);
  console.log(`   Rejected: ${status.rejected}`);

  // 3. Pending Organizations (need approval)
  if (status.pending > 0) {
    const pendingOrgs = await sso.platform.organizations.list({
      status: 'pending',
      limit: 10
    });

    console.log('\nORGANIZATIONS AWAITING APPROVAL:');
    pendingOrgs.organizations.forEach(org => {
      console.log(`  - ${org.name} (${org.slug})`);
      console.log(`    Owner: ${org.owner_email}`);
      console.log(`    Created: ${new Date(org.created_at).toLocaleDateString()}`);
    });
  }

  // 4. Top Organizations
  const topOrgs = await sso.platform.analytics.getTopOrganizations();
  console.log('\nTOP 5 MOST ACTIVE ORGANIZATIONS:');
  topOrgs.slice(0, 5).forEach((org, index) => {
    console.log(`  ${index + 1}. ${org.name}`);
    console.log(`     Logins (30d): ${org.login_count_30d}`);
    console.log(`     Active Users: ${org.unique_users_30d}/${org.user_count}`);
  });

  // 5. Recent Activity
  const recent = await sso.platform.analytics.getRecentOrganizations({ limit: 5 });
  console.log('\nRECENTLY CREATED ORGANIZATIONS:');
  recent.forEach(org => {
    const daysAgo = Math.floor((Date.now() - new Date(org.created_at).getTime()) / (1000 * 60 * 60 * 24));
    console.log(`  - ${org.name} (${daysAgo} days ago) - Status: ${org.status}`);
  });

  // 6. Audit Log Summary
  const auditLogs = await sso.platform.getAuditLog({ limit: 10 });
  console.log('\nRECENT ADMINISTRATIVE ACTIONS:');
  auditLogs.forEach(log => {
    console.log(`  [${new Date(log.created_at).toLocaleString()}]`);
    console.log(`  ${log.actor_email}: ${log.action}`);
  });
}

// Run the dashboard
displayPlatformDashboard();

interface PlatformOrganizationResponse {
  id: string;
  slug: string;
  name: string;
  owner_user_id: string;
  status: OrganizationStatus;
  tier_id: string;
  max_services?: number | null;
  max_users?: number | null;
  approved_by?: string | null;
  approved_at?: string | null;
  rejected_by?: string | null;
  rejected_at?: string | null;
  rejection_reason?: string | null;
  created_at: string;
  updated_at: string;
  tier: OrganizationTier;
  owner: User;
}

interface ApproveOrganizationPayload {
  tier_id: string;
}

interface RejectOrganizationPayload {
  reason: string;
}

interface UpdateOrganizationTierPayload {
  tier_id: string;
  max_services?: number;
  max_users?: number;
}

interface PromotePlatformOwnerPayload {
  user_id: string;
}

interface AuditLogEntry {
  id: string;
  user_id: string;
  user_email: string;
  action: string;
  resource_type: string;
  resource_id: string;
  details?: Record<string, any>;
  ip_address?: string;
  user_agent?: string;
  created_at: string;
}

interface ListPlatformOrganizationsParams {
  page?: number;
  limit?: number;
  status?: OrganizationStatus;
  search?: string;
  tier_id?: string;
}

interface GetAuditLogParams {
  page?: number;
  limit?: number;
  user_id?: string;
  action?: string;
  resource_type?: string;
  start_date?: string;
  end_date?: string;
}

interface PlatformOverviewMetrics {
  total_organizations: number;
  total_users: number;
  total_end_users: number;
  total_services: number;
  total_logins_24h: number;
  total_logins_30d: number;
}

interface OrganizationStatusBreakdown {
  pending: number;
  active: number;
  suspended: number;
  rejected: number;
}

interface GrowthTrendPoint {
  date: string;
  new_organizations: number;
  new_users: number;
}

interface LoginActivityPoint {
  date: string;
  count: number;
}

interface TopOrganization {
  id: string;
  name: string;
  slug: string;
  user_count: number;
  service_count: number;
  login_count_30d: number;
}

interface RecentOrganization {
  id: string;
  name: string;
  slug: string;
  status: OrganizationStatus;
  created_at: string;
}

type OrganizationStatus = 'pending' | 'active' | 'suspended' | 'rejected';