API Module - TypeScript Functions
🔑 TokensComponent Functions
Advanced component for managing API tokens with security monitoring, analytics, and comprehensive permission management.
Component Properties
export class TokensComponent implements OnInit, OnDestroy {
// Data Properties
tokens: ApiToken[] = [];
filteredTokens: ApiToken[] = [];
selectedToken: ApiToken | null = null;
currentUser: User | null = null;
loading: boolean = false;
error: string | null = null;
// Filter and Search Properties
searchTerm: string = '';
statusFilter: TokenStatus = TokenStatus.ALL;
permissionFilter: string = '';
expirationFilter: ExpirationFilter = ExpirationFilter.ALL;
// Pagination Properties
currentPage: number = 1;
itemsPerPage: number = 10;
totalItems: number = 0;
// Sorting Properties
sortField: string = 'createdAt';
sortDirection: 'asc' | 'desc' = 'desc';
// UI State Properties
showTokenDetails: boolean = false;
showRevokeModal: boolean = false;
showRenewModal: boolean = false;
showPermissionsModal: boolean = false;
isEditing: boolean = false;
// Analytics Properties
usageStatistics: TokenUsageStatistics[] = [];
selectedPeriod: TimePeriod = TimePeriod.LAST_30_DAYS;
// Security Properties
securityEvents: SecurityEvent[] = [];
showSecurityAlert: boolean = false;
}🔄 Lifecycle Methods
/**
* Component initialization
*/
ngOnInit(): void
/**
* Component cleanup
*/
ngOnDestroy(): void
/**
* After view initialization
*/
ngAfterViewInit(): void📥 Data Loading Methods
/**
* Load all API tokens
*/
loadTokens(): void
/**
* Load tokens with pagination
* @param page - Page number to load
* @param pageSize - Number of items per page
*/
loadTokensWithPagination(page: number, pageSize: number): void
/**
* Load token by ID
* @param tokenId - Token ID to load
*/
loadTokenById(tokenId: string): void
/**
* Refresh token list
*/
refreshTokens(): void
/**
* Load token usage statistics
* @param tokenId - Token ID
* @param period - Time period for statistics
*/
loadTokenUsage(tokenId: string, period: TimePeriod): void
/**
* Load security events for token
* @param tokenId - Token ID
*/
loadSecurityEvents(tokenId: string): void
/**
* Load active sessions for token
* @param tokenId - Token ID
*/
loadActiveSessions(tokenId: string): void🔑 Token Management Methods
/**
* View token details
* @param token - Token to view
*/
viewTokenDetails(token: ApiToken): void
/**
* Revoke API token
* @param tokenId - Token ID to revoke
* @param reason - Revocation reason
*/
revokeToken(tokenId: string, reason: string): void
/**
* Renew API token
* @param tokenId - Token ID to renew
* @param newExpiration - New expiration date
*/
renewToken(tokenId: string, newExpiration: Date): void
/**
* Rotate token (generate new token with same permissions)
* @param tokenId - Token ID to rotate
*/
rotateToken(tokenId: string): void
/**
* Suspend token temporarily
* @param tokenId - Token ID to suspend
* @param reason - Suspension reason
*/
suspendToken(tokenId: string, reason: string): void
/**
* Reactivate suspended token
* @param tokenId - Token ID to reactivate
*/
reactivateToken(tokenId: string): void
/**
* Update token permissions
* @param tokenId - Token ID
* @param permissions - New permissions
*/
updateTokenPermissions(tokenId: string, permissions: ApiPermission[]): void
/**
* Update token metadata
* @param tokenId - Token ID
* @param metadata - Updated metadata
*/
updateTokenMetadata(tokenId: string, metadata: TokenMetadata): void🔐 Permission Management Methods
/**
* Open permissions modal
* @param token - Token to manage permissions for
*/
openPermissionsModal(token: ApiToken): void
/**
* Close permissions modal
*/
closePermissionsModal(): void
/**
* Add permission to token
* @param tokenId - Token ID
* @param permission - Permission to add
*/
addPermission(tokenId: string, permission: ApiPermission): void
/**
* Remove permission from token
* @param tokenId - Token ID
* @param permissionId - Permission ID to remove
*/
removePermission(tokenId: string, permissionId: string): void
/**
* Update permission level
* @param tokenId - Token ID
* @param permissionId - Permission ID
* @param level - New permission level
*/
updatePermissionLevel(tokenId: string, permissionId: string, level: PermissionLevel): void
/**
* Bulk update permissions
* @param tokenId - Token ID
* @param permissions - Array of permissions
*/
bulkUpdatePermissions(tokenId: string, permissions: ApiPermission[]): void🔍 Search and Filter Methods
/**
* Search tokens by term
* @param searchTerm - Search term
*/
searchTokens(searchTerm: string): void
/**
* Filter tokens by status
* @param status - Token status
*/
filterByStatus(status: TokenStatus): void
/**
* Filter tokens by permission
* @param permission - Permission type
*/
filterByPermission(permission: string): void
/**
* Filter tokens by expiration
* @param filter - Expiration filter
*/
filterByExpiration(filter: ExpirationFilter): void
/**
* Apply all filters
*/
applyFilters(): void
/**
* Clear all filters
*/
clearFilters(): void
/**
* Reset search and filters
*/
resetFilters(): void📊 Analytics and Monitoring Methods
/**
* Load usage analytics for period
* @param period - Time period
*/
loadUsageAnalytics(period: TimePeriod): void
/**
* Get token performance metrics
* @param tokenId - Token ID
*/
getTokenPerformanceMetrics(tokenId: string): void
/**
* Monitor real-time token usage
* @param tokenId - Token ID
*/
monitorRealTimeUsage(tokenId: string): void
/**
* Generate usage report
* @param tokenIds - Array of token IDs
* @param period - Reporting period
*/
generateUsageReport(tokenIds: string[], period: TimePeriod): void
/**
* Export usage data
* @param format - Export format (CSV, JSON, PDF)
*/
exportUsageData(format: ExportFormat): void
/**
* Get rate limiting statistics
* @param tokenId - Token ID
*/
getRateLimitingStats(tokenId: string): void🛡️ Security Methods
/**
* Monitor security events
*/
monitorSecurityEvents(): void
/**
* Handle security alert
* @param event - Security event
*/
handleSecurityAlert(event: SecurityEvent): void
/**
* Block suspicious IP
* @param tokenId - Token ID
* @param ipAddress - IP address to block
*/
blockSuspiciousIP(tokenId: string, ipAddress: string): void
/**
* Enable two-factor authentication for token
* @param tokenId - Token ID
*/
enableTwoFactorAuth(tokenId: string): void
/**
* Set IP restrictions
* @param tokenId - Token ID
* @param ipRestrictions - IP restriction rules
*/
setIPRestrictions(tokenId: string, ipRestrictions: IPRestriction[]): void
/**
* Configure rate limits
* @param tokenId - Token ID
* @param rateLimits - Rate limit configuration
*/
configureRateLimits(tokenId: string, rateLimits: RateLimit[]): void🖱️ UI Interaction Methods
/**
* Toggle token details view
* @param token - Token to toggle
*/
toggleTokenDetails(token: ApiToken): void
/**
* Open revoke confirmation modal
* @param token - Token to revoke
*/
openRevokeModal(token: ApiToken): void
/**
* Close revoke modal
*/
closeRevokeModal(): void
/**
* Open renewal modal
* @param token - Token to renew
*/
openRenewModal(token: ApiToken): void
/**
* Close renewal modal
*/
closeRenewModal(): void
/**
* Copy token to clipboard
* @param token - Token to copy
*/
copyTokenToClipboard(token: string): void
/**
* Show token QR code
* @param token - Token for QR code
*/
showTokenQRCode(token: string): void➕ AddtokenComponent Functions
Multi-step wizard component for creating new API tokens with comprehensive configuration options and security settings.
Component Properties
export class AddtokenComponent implements OnInit {
// Form Properties
tokenForm: FormGroup;
permissionsForm: FormGroup;
restrictionsForm: FormGroup;
// Data Properties
availablePermissions: ApiPermission[] = [];
selectedPermissions: ApiPermission[] = [];
availableEndpoints: ApiEndpoint[] = [];
selectedEndpoints: ApiEndpoint[] = [];
// UI State Properties
currentStep: number = 1;
totalSteps: number = 4;
loading: boolean = false;
error: string | null = null;
isSubmitting: boolean = false;
// Generated Token Properties
generatedToken: string | null = null;
tokenSecret: string | null = null;
showTokenDetails: boolean = false;
// Configuration Properties
expirationOptions: ExpirationOption[] = [];
rateLimitOptions: RateLimitOption[] = [];
ipRestrictionEnabled: boolean = false;
}🔄 Lifecycle Methods
/**
* Component initialization
*/
ngOnInit(): void
/**
* Component cleanup
*/
ngOnDestroy(): void📝 Form Management Methods
/**
* Initialize token creation form
*/
initializeForm(): void
/**
* Initialize permissions form
*/
initializePermissionsForm(): void
/**
* Initialize restrictions form
*/
initializeRestrictionsForm(): void
/**
* Validate current step
*/
validateCurrentStep(): boolean
/**
* Move to next step
*/
nextStep(): void
/**
* Move to previous step
*/
previousStep(): void
/**
* Submit token creation form
*/
submitForm(): void
/**
* Reset form to initial state
*/
resetForm(): void
/**
* Save as draft
*/
saveAsDraft(): void
/**
* Load from draft
* @param draftId - Draft ID to load
*/
loadFromDraft(draftId: string): void📥 Data Loading Methods
/**
* Load available permissions
*/
loadAvailablePermissions(): void
/**
* Load available API endpoints
*/
loadAvailableEndpoints(): void
/**
* Load token templates
*/
loadTokenTemplates(): void
/**
* Load expiration options
*/
loadExpirationOptions(): void
/**
* Load rate limit templates
*/
loadRateLimitTemplates(): void🔐 Permission Configuration Methods
/**
* Add permission to token
* @param permission - Permission to add
*/
addPermission(permission: ApiPermission): void
/**
* Remove permission from token
* @param permission - Permission to remove
*/
removePermission(permission: ApiPermission): void
/**
* Select all permissions
*/
selectAllPermissions(): void
/**
* Clear all permissions
*/
clearAllPermissions(): void
/**
* Apply permission template
* @param template - Permission template
*/
applyPermissionTemplate(template: PermissionTemplate): void
/**
* Configure custom permission
* @param endpoint - API endpoint
* @param level - Permission level
*/
configureCustomPermission(endpoint: string, level: PermissionLevel): void🔑 Token Generation Methods
/**
* Generate new API token
* @param tokenData - Token configuration data
*/
generateToken(tokenData: CreateTokenRequest): void
/**
* Generate token secret
*/
generateTokenSecret(): string
/**
* Validate token configuration
*/
validateTokenConfig(): boolean
/**
* Preview token configuration
*/
previewTokenConfig(): void
/**
* Test token generation
*/
testTokenGeneration(): void✅ Validation Methods
/**
* Validate token name
* @param name - Token name to validate
*/
validateTokenName(name: string): boolean
/**
* Validate expiration date
* @param date - Expiration date to validate
*/
validateExpirationDate(date: Date): boolean
/**
* Validate IP restrictions
* @param ipList - List of IP addresses
*/
validateIPRestrictions(ipList: string[]): boolean
/**
* Validate rate limits
* @param rateLimits - Rate limit configuration
*/
validateRateLimits(rateLimits: RateLimit[]): boolean
/**
* Check token name uniqueness
* @param name - Token name to check
*/
checkTokenNameUniqueness(name: string): void⚙️ Configuration Methods
/**
* Configure token expiration
* @param expiration - Expiration configuration
*/
configureExpiration(expiration: ExpirationConfig): void
/**
* Configure rate limiting
* @param rateLimits - Rate limit rules
*/
configureRateLimiting(rateLimits: RateLimit[]): void
/**
* Configure IP restrictions
* @param ipRestrictions - IP restriction rules
*/
configureIPRestrictions(ipRestrictions: IPRestriction[]): void
/**
* Configure geographic restrictions
* @param geoRestrictions - Geographic restrictions
*/
configureGeoRestrictions(geoRestrictions: GeoRestriction[]): void
/**
* Configure usage quotas
* @param quotas - Usage quota configuration
*/
configureUsageQuotas(quotas: UsageQuota[]): void⚙️ ApiService Functions
Core service for API token management, authentication, usage tracking, and security monitoring with comprehensive caching.
Service Properties
export class ApiService {
// Private properties
private readonly apiUrl = 'api/tokens';
private readonly authUrl = 'api/auth';
private tokensSubject = new BehaviorSubject<ApiToken[]>([]);
private loadingSubject = new BehaviorSubject<boolean>(false);
private errorSubject = new BehaviorSubject<string | null>(null);
// Public observables
public tokens$ = this.tokensSubject.asObservable();
public loading$ = this.loadingSubject.asObservable();
public error$ = this.errorSubject.asObservable();
// Cache properties
private tokenCache = new Map<string, ApiToken>();
private permissionsCache = new Map<string, ApiPermission[]>();
}📊 Token CRUD Operations
/**
* Generate new API token
* @param tokenData - Token creation data
*/
generateToken(tokenData: CreateTokenRequest): Observable<ApiToken>
/**
* Get all API tokens
* @param filters - Optional filters
*/
getAllTokens(filters?: TokenFilters): Observable<ApiToken[]>
/**
* Get token by ID
* @param tokenId - Token ID
*/
getTokenById(tokenId: string): Observable<ApiToken>
/**
* Update token metadata
* @param tokenId - Token ID
* @param metadata - Updated metadata
*/
updateToken(tokenId: string, metadata: UpdateTokenRequest): Observable<ApiToken>
/**
* Revoke API token
* @param tokenId - Token ID
* @param reason - Revocation reason
*/
revokeToken(tokenId: string, reason: string): Observable<void>
/**
* Suspend token
* @param tokenId - Token ID
* @param reason - Suspension reason
*/
suspendToken(tokenId: string, reason: string): Observable<void>
/**
* Reactivate token
* @param tokenId - Token ID
*/
reactivateToken(tokenId: string): Observable<void>
/**
* Rotate token (generate new with same permissions)
* @param tokenId - Token ID
*/
rotateToken(tokenId: string): Observable<ApiToken>🔐 Token Validation and Authentication
/**
* Validate token authenticity
* @param token - Token to validate
*/
validateToken(token: string): Observable<TokenValidationResult>
/**
* Verify token permissions for endpoint
* @param token - Token to verify
* @param endpoint - API endpoint
* @param method - HTTP method
*/
verifyTokenPermissions(token: string, endpoint: string, method: string): Observable<boolean>
/**
* Authenticate API request
* @param token - Authentication token
* @param request - API request details
*/
authenticateRequest(token: string, request: ApiRequest): Observable<AuthResult>
/**
* Refresh token if needed
* @param token - Token to refresh
*/
refreshTokenIfNeeded(token: string): Observable<string>
/**
* Check token expiration
* @param tokenId - Token ID
*/
checkTokenExpiration(tokenId: string): Observable<ExpirationStatus>🔒 Permission Management
/**
* Get token permissions
* @param tokenId - Token ID
*/
getTokenPermissions(tokenId: string): Observable<ApiPermission[]>
/**
* Update token permissions
* @param tokenId - Token ID
* @param permissions - New permissions
*/
updateTokenPermissions(tokenId: string, permissions: ApiPermission[]): Observable<void>
/**
* Add permission to token
* @param tokenId - Token ID
* @param permission - Permission to add
*/
addPermission(tokenId: string, permission: ApiPermission): Observable<void>
/**
* Remove permission from token
* @param tokenId - Token ID
* @param permissionId - Permission ID to remove
*/
removePermission(tokenId: string, permissionId: string): Observable<void>
/**
* Get available permissions
*/
getAvailablePermissions(): Observable<ApiPermission[]>
/**
* Validate permission configuration
* @param permissions - Permissions to validate
*/
validatePermissions(permissions: ApiPermission[]): Observable<ValidationResult>📈 Usage Tracking and Analytics
/**
* Get token usage statistics
* @param tokenId - Token ID
* @param period - Time period
*/
getTokenUsage(tokenId: string, period: TimePeriod): Observable<TokenUsageStatistics>
/**
* Track API call
* @param tokenId - Token ID
* @param callData - API call data
*/
trackApiCall(tokenId: string, callData: ApiCall): Observable<void>
/**
* Get usage analytics
* @param tokenIds - Array of token IDs
* @param period - Analysis period
*/
getUsageAnalytics(tokenIds: string[], period: TimePeriod): Observable<UsageAnalytics>
/**
* Get performance metrics
* @param tokenId - Token ID
*/
getPerformanceMetrics(tokenId: string): Observable<PerformanceMetrics>
/**
* Generate usage report
* @param tokenIds - Token IDs
* @param format - Report format
* @param period - Reporting period
*/
generateUsageReport(tokenIds: string[], format: ReportFormat, period: TimePeriod): Observable<Blob>🛡️ Rate Limiting and Security
/**
* Configure rate limits for token
* @param tokenId - Token ID
* @param rateLimits - Rate limit configuration
*/
configureRateLimits(tokenId: string, rateLimits: RateLimit[]): Observable<void>
/**
* Get rate limit status
* @param tokenId - Token ID
*/
getRateLimitStatus(tokenId: string): Observable<RateLimitStatus>
/**
* Configure IP restrictions
* @param tokenId - Token ID
* @param ipRestrictions - IP restrictions
*/
configureIPRestrictions(tokenId: string, ipRestrictions: IPRestriction[]): Observable<void>
/**
* Block IP address
* @param tokenId - Token ID
* @param ipAddress - IP address to block
* @param reason - Block reason
*/
blockIPAddress(tokenId: string, ipAddress: string, reason: string): Observable<void>
/**
* Get security events
* @param tokenId - Token ID
* @param period - Time period
*/
getSecurityEvents(tokenId: string, period: TimePeriod): Observable<SecurityEvent[]>
/**
* Report security incident
* @param tokenId - Token ID
* @param incident - Incident details
*/
reportSecurityIncident(tokenId: string, incident: SecurityIncident): Observable<void>📊 Monitoring and Health
/**
* Monitor token health
* @param tokenId - Token ID
*/
monitorTokenHealth(tokenId: string): Observable<TokenHealth>
/**
* Get API health status
*/
getApiHealthStatus(): Observable<ApiHealthStatus>
/**
* Monitor real-time usage
* @param tokenId - Token ID
*/
monitorRealTimeUsage(tokenId: string): Observable<RealTimeUsage>
/**
* Check API endpoint availability
* @param endpoint - API endpoint
*/
checkEndpointAvailability(endpoint: string): Observable<EndpointStatus>
/**
* Get system performance metrics
*/
getSystemPerformanceMetrics(): Observable<SystemPerformance>💾 Cache Management
/**
* Cache token data
* @param token - Token to cache
*/
private cacheToken(token: ApiToken): void
/**
* Get cached token
* @param tokenId - Token ID
*/
private getCachedToken(tokenId: string): ApiToken | null
/**
* Clear token cache
* @param tokenId - Token ID (optional, clears all if not provided)
*/
clearCache(tokenId?: string): void
/**
* Refresh cache
*/
refreshCache(): void
/**
* Validate cache integrity
*/
validateCacheIntegrity(): boolean⚠️ Error Handling and Logging
/**
* Handle HTTP errors
* @param error - HTTP error response
*/
private handleError(error: HttpErrorResponse): Observable<never>
/**
* Log API operation
* @param operation - Operation details
*/
private logOperation(operation: ApiOperation): void
/**
* Handle authentication errors
* @param error - Authentication error
*/
private handleAuthError(error: AuthError): void
/**
* Retry failed operations
* @param operation - Failed operation
* @param maxRetries - Maximum retry attempts
*/
private retryOperation<T>(operation: Observable<T>, maxRetries: number): Observable<T>📦 ApiClass Functions
Token model class with comprehensive validation, permission management, and utility methods for API token operations.
Class Properties
export class ApiClass {
// Token properties
public id: string;
public name: string;
public token: string;
public secret: string;
public status: TokenStatus;
public createdAt: Date;
public expiresAt: Date;
public lastUsedAt?: Date;
// Permission properties
public permissions: ApiPermission[];
public scopes: string[];
// Usage properties
public usageCount: number;
public rateLimits: RateLimit[];
public restrictions: TokenRestriction[];
}🏗️ Constructor and Factory Methods
/**
* Constructor for ApiClass
* @param data - Token data
*/
constructor(data: TokenData)
/**
* Create token from API response
* @param response - API response data
*/
static fromApiResponse(response: any): ApiClass
/**
* Create token with default values
* @param name - Token name
* @param permissions - Initial permissions
*/
static createDefault(name: string, permissions: ApiPermission[]): ApiClass
/**
* Clone existing token
* @param originalToken - Token to clone
*/
static clone(originalToken: ApiClass): ApiClass🔧 Token Management Methods
/**
* Validate token structure
*/
validate(): ValidationResult
/**
* Check if token is expired
*/
isExpired(): boolean
/**
* Check if token is active
*/
isActive(): boolean
/**
* Get token age in days
*/
getTokenAge(): number
/**
* Calculate days until expiration
*/
getDaysUntilExpiration(): number
/**
* Check if token needs renewal
* @param thresholdDays - Days before expiration to trigger renewal
*/
needsRenewal(thresholdDays: number = 30): boolean🔐 Permission Methods
/**
* Check if token has specific permission
* @param permission - Permission to check
*/
hasPermission(permission: string): boolean
/**
* Check if token has access to endpoint
* @param endpoint - API endpoint
* @param method - HTTP method
*/
hasEndpointAccess(endpoint: string, method: string): boolean
/**
* Add permission to token
* @param permission - Permission to add
*/
addPermission(permission: ApiPermission): void
/**
* Remove permission from token
* @param permissionId - Permission ID to remove
*/
removePermission(permissionId: string): void
/**
* Get permission level for endpoint
* @param endpoint - API endpoint
*/
getPermissionLevel(endpoint: string): PermissionLevel
/**
* Update permission level
* @param endpoint - API endpoint
* @param level - New permission level
*/
updatePermissionLevel(endpoint: string, level: PermissionLevel): void📊 Usage Tracking Methods
/**
* Increment usage count
*/
incrementUsage(): void
/**
* Update last used timestamp
*/
updateLastUsed(): void
/**
* Check rate limit status
* @param operation - Operation type
*/
checkRateLimit(operation: string): RateLimitResult
/**
* Apply rate limit
* @param operation - Operation type
*/
applyRateLimit(operation: string): void
/**
* Get usage statistics
* @param period - Time period
*/
getUsageStats(period: TimePeriod): UsageStatistics🔄 Serialization Methods
/**
* Convert to JSON
*/
toJSON(): object
/**
* Convert to API request format
*/
toApiFormat(): any
/**
* Convert to display format
*/
toDisplayFormat(): TokenDisplayData
/**
* Export token data
* @param format - Export format
*/
export(format: ExportFormat): string
/**
* Generate token summary
*/
generateSummary(): TokenSummary🛡️ Security Methods
/**
* Mask sensitive token data
*/
maskSensitiveData(): ApiClass
/**
* Generate secure hash
*/
generateSecureHash(): string
/**
* Verify token integrity
* @param signature - Security signature
*/
verifyIntegrity(signature: string): boolean
/**
* Check for security violations
*/
checkSecurityViolations(): SecurityViolation[]
/**
* Apply security restrictions
* @param restrictions - Security restrictions
*/
applySecurityRestrictions(restrictions: SecurityRestriction[]): void📋 Interface Definitions
Core Interfaces
interface ApiToken {
id: string;
name: string;
token: string;
secret: string;
status: TokenStatus;
permissions: ApiPermission[];
scopes: string[];
createdAt: Date;
expiresAt: Date;
lastUsedAt?: Date;
usageCount: number;
rateLimits: RateLimit[];
restrictions: TokenRestriction[];
metadata: TokenMetadata;
}
interface ApiPermission {
id: string;
name: string;
description: string;
endpoint: string;
methods: string[];
level: PermissionLevel;
scopes: string[];
}
interface CreateTokenRequest {
name: string;
description?: string;
permissions: string[];
expiresAt: Date;
rateLimits?: RateLimit[];
restrictions?: TokenRestriction[];
metadata?: TokenMetadata;
}
interface TokenUsageStatistics {
tokenId: string;
totalCalls: number;
successfulCalls: number;
failedCalls: number;
averageResponseTime: number;
rateLimitHits: number;
period: TimePeriod;
breakdown: UsageBreakdown[];
}
interface SecurityEvent {
id: string;
tokenId: string;
eventType: SecurityEventType;
severity: SecuritySeverity;
description: string;
ipAddress: string;
userAgent: string;
timestamp: Date;
resolved: boolean;
}
interface RateLimit {
operation: string;
limit: number;
period: number;
unit: TimeUnit;
burst?: number;
}Enums
enum TokenStatus {
ACTIVE = 'active',
SUSPENDED = 'suspended',
REVOKED = 'revoked',
EXPIRED = 'expired'
}
enum PermissionLevel {
READ = 'read',
WRITE = 'write',
ADMIN = 'admin',
FULL = 'full'
}
enum SecurityEventType {
SUSPICIOUS_ACTIVITY = 'suspicious_activity',
RATE_LIMIT_EXCEEDED = 'rate_limit_exceeded',
UNAUTHORIZED_ACCESS = 'unauthorized_access',
INVALID_TOKEN = 'invalid_token',
IP_BLOCKED = 'ip_blocked'
}
enum TimePeriod {
LAST_HOUR = 'last_hour',
LAST_24_HOURS = 'last_24_hours',
LAST_7_DAYS = 'last_7_days',
LAST_30_DAYS = 'last_30_days',
LAST_90_DAYS = 'last_90_days'
}