notification-kit/dist/types/permissions.d.ts

A unified notification library for React + Capacitor apps. One API for push notifications, in-app notifications, and local notifications across Web, iOS, and Android.

import { ComponentType } from 'react';
export type PermissionStatus = 'granted' | 'denied' | 'prompt' | 'default' | 'unknown';
export type PermissionType = 'notifications' | 'push' | 'local' | 'camera' | 'microphone' | 'location' | 'storage';
export interface PermissionRequestOptions {
    type: PermissionType;
    showRationale?: boolean;
    rationaleTitle?: string;
    rationaleMessage?: string;
    rationaleButtonText?: string;
    fallbackToSettings?: boolean;
    settingsTitle?: string;
    settingsMessage?: string;
    settingsButtonText?: string;
    cancelButtonText?: string;
    persistent?: boolean;
    timeout?: number;
    retryAttempts?: number;
    retryDelay?: number;
    customPrompt?: boolean;
    customPromptComponent?: ComponentType<PermissionPromptProps>;
    analytics?: boolean;
    metadata?: Record<string, any>;
}
export interface PermissionPromptProps {
    type: PermissionType;
    status: PermissionStatus;
    title: string;
    message: string;
    allowButtonText: string;
    denyButtonText: string;
    onAllow: () => void;
    onDeny: () => void;
    onDismiss: () => void;
    options: PermissionRequestOptions;
}
export interface PermissionCheckResult {
    status: PermissionStatus;
    canRequest: boolean;
    shouldShowRationale: boolean;
    deniedCount: number;
    lastRequested?: Date;
    lastDenied?: Date;
    lastGranted?: Date;
    metadata?: Record<string, any>;
}
export interface PermissionRequestResult {
    status: PermissionStatus;
    granted: boolean;
    denied: boolean;
    prompt: boolean;
    rationale: boolean;
    settings: boolean;
    duration: number;
    userInteraction: boolean;
    fromCache: boolean;
    metadata?: Record<string, any>;
}
export interface PermissionBatchRequestOptions {
    permissions: PermissionType[];
    mode: 'all' | 'any' | 'sequential';
    continueOnDenied?: boolean;
    showRationale?: boolean;
    fallbackToSettings?: boolean;
    timeout?: number;
    retryAttempts?: number;
    retryDelay?: number;
    analytics?: boolean;
    metadata?: Record<string, any>;
}
export interface PermissionBatchRequestResult {
    results: Record<PermissionType, PermissionRequestResult>;
    allGranted: boolean;
    anyGranted: boolean;
    allDenied: boolean;
    anyDenied: boolean;
    duration: number;
    errors: PermissionError[];
    metadata?: Record<string, any>;
}
export interface PermissionError {
    type: PermissionType;
    code: string;
    message: string;
    details?: any;
    timestamp: Date;
    retryable: boolean;
    suggestions: string[];
}
export interface PermissionSettings {
    autoRequest?: boolean;
    showRationale?: boolean;
    fallbackToSettings?: boolean;
    persistent?: boolean;
    timeout?: number;
    retryAttempts?: number;
    retryDelay?: number;
    cacheExpiry?: number;
    analytics?: boolean;
    customPrompts?: Record<PermissionType, ComponentType<PermissionPromptProps>>;
    rationales?: Record<PermissionType, PermissionRationale>;
    fallbacks?: Record<PermissionType, PermissionFallback>;
    middleware?: PermissionMiddleware[];
}
export interface PermissionRationale {
    title: string;
    message: string;
    buttonText: string;
    cancelText?: string;
    icon?: string;
    image?: string;
    video?: string;
    customComponent?: ComponentType<PermissionRationaleProps>;
    showOnce?: boolean;
    priority?: number;
    conditions?: PermissionCondition[];
}
export interface PermissionRationaleProps {
    type: PermissionType;
    rationale: PermissionRationale;
    onAccept: () => void;
    onDecline: () => void;
    onDismiss: () => void;
}
export interface PermissionFallback {
    type: 'settings' | 'alternative' | 'graceful' | 'custom';
    title: string;
    message: string;
    buttonText: string;
    cancelText?: string;
    settingsDeepLink?: string;
    alternativeAction?: () => void;
    customComponent?: ComponentType<PermissionFallbackProps>;
    showOnce?: boolean;
    priority?: number;
    conditions?: PermissionCondition[];
}
export interface PermissionFallbackProps {
    type: PermissionType;
    fallback: PermissionFallback;
    onAction: () => void;
    onCancel: () => void;
    onDismiss: () => void;
}
export interface PermissionCondition {
    type: 'platform' | 'version' | 'feature' | 'setting' | 'custom';
    value: any;
    operator: 'equals' | 'not_equals' | 'greater' | 'less' | 'contains' | 'regex' | 'custom';
    customCheck?: () => boolean;
}
export interface PermissionMiddleware {
    name: string;
    before?: (type: PermissionType, options: PermissionRequestOptions) => PermissionRequestOptions | null;
    after?: (type: PermissionType, result: PermissionRequestResult) => void;
    error?: (type: PermissionType, error: PermissionError) => void;
    priority?: number;
    enabled?: boolean;
    config?: Record<string, any>;
}
export interface PermissionManager {
    check(type: PermissionType): Promise<PermissionCheckResult>;
    request(type: PermissionType, options?: PermissionRequestOptions): Promise<PermissionRequestResult>;
    batchRequest(options: PermissionBatchRequestOptions): Promise<PermissionBatchRequestResult>;
    openSettings(type?: PermissionType): Promise<void>;
    isSupported(type: PermissionType): boolean;
    getCapabilities(): PermissionCapabilities;
    configure(settings: PermissionSettings): void;
    middleware(middleware: PermissionMiddleware): void;
    on(event: PermissionEventType, listener: PermissionEventListener): () => void;
    off(event: PermissionEventType, listener: PermissionEventListener): void;
    emit(event: PermissionEventType, data: any): void;
    clear(): Promise<void>;
    export(): Promise<PermissionExport>;
    import(data: PermissionImport): Promise<void>;
    stats(): PermissionStats;
}
export interface PermissionCapabilities {
    types: PermissionType[];
    rationale: boolean;
    settings: boolean;
    batch: boolean;
    timeout: boolean;
    retry: boolean;
    cache: boolean;
    analytics: boolean;
    customPrompts: boolean;
    middleware: boolean;
    events: boolean;
    export: boolean;
    import: boolean;
    stats: boolean;
}
export type PermissionEventType = 'requested' | 'granted' | 'denied' | 'changed' | 'rationale_shown' | 'settings_opened' | 'error' | 'timeout' | 'retry' | 'cache_hit' | 'cache_miss';
export interface PermissionEventListener {
    (event: PermissionEvent): void;
}
export interface PermissionEvent {
    type: PermissionEventType;
    permission: PermissionType;
    status: PermissionStatus;
    result?: PermissionRequestResult;
    error?: PermissionError;
    timestamp: Date;
    metadata?: Record<string, any>;
}
export interface PermissionExport {
    version: string;
    timestamp: Date;
    permissions: Record<PermissionType, PermissionExportData>;
    settings: PermissionSettings;
    stats: PermissionStats;
    metadata?: Record<string, any>;
}
export interface PermissionExportData {
    status: PermissionStatus;
    deniedCount: number;
    grantedCount: number;
    requestCount: number;
    lastRequested?: Date;
    lastGranted?: Date;
    lastDenied?: Date;
    history: PermissionHistoryEntry[];
    metadata?: Record<string, any>;
}
export interface PermissionImport {
    version: string;
    timestamp: Date;
    permissions: Record<PermissionType, PermissionImportData>;
    settings?: PermissionSettings;
    overwrite?: boolean;
    merge?: boolean;
    validate?: boolean;
    metadata?: Record<string, any>;
}
export interface PermissionImportData {
    status: PermissionStatus;
    deniedCount: number;
    grantedCount: number;
    requestCount: number;
    lastRequested?: Date;
    lastGranted?: Date;
    lastDenied?: Date;
    history: PermissionHistoryEntry[];
    metadata?: Record<string, any>;
}
export interface PermissionHistoryEntry {
    timestamp: Date;
    status: PermissionStatus;
    action: 'requested' | 'granted' | 'denied' | 'changed';
    duration?: number;
    userInteraction: boolean;
    rationale: boolean;
    settings: boolean;
    source: 'user' | 'system' | 'app';
    metadata?: Record<string, any>;
}
export interface PermissionStats {
    total: PermissionStatsTotal;
    byType: Record<PermissionType, PermissionStatsType>;
    byStatus: Record<PermissionStatus, PermissionStatsStatus>;
    trends: PermissionStatsTrend[];
    performance: PermissionStatsPerformance;
    errors: PermissionStatsError[];
    metadata?: Record<string, any>;
}
export interface PermissionStatsTotal {
    requests: number;
    granted: number;
    denied: number;
    rationales: number;
    settings: number;
    timeouts: number;
    retries: number;
    errors: number;
    cacheHits: number;
    cacheMisses: number;
    avgDuration: number;
    maxDuration: number;
    minDuration: number;
    successRate: number;
    denialRate: number;
    timeoutRate: number;
    retryRate: number;
    errorRate: number;
    cacheHitRate: number;
}
export interface PermissionStatsType {
    type: PermissionType;
    requests: number;
    granted: number;
    denied: number;
    rationales: number;
    settings: number;
    timeouts: number;
    retries: number;
    errors: number;
    cacheHits: number;
    cacheMisses: number;
    avgDuration: number;
    maxDuration: number;
    minDuration: number;
    successRate: number;
    denialRate: number;
    timeoutRate: number;
    retryRate: number;
    errorRate: number;
    cacheHitRate: number;
    lastRequested?: Date;
    lastGranted?: Date;
    lastDenied?: Date;
}
export interface PermissionStatsStatus {
    status: PermissionStatus;
    count: number;
    percentage: number;
    types: PermissionType[];
    avgDuration: number;
    trend: 'up' | 'down' | 'stable';
    change: number;
    changePercentage: number;
}
export interface PermissionStatsTrend {
    type: PermissionType;
    metric: 'requests' | 'granted' | 'denied' | 'success_rate' | 'denial_rate';
    data: PermissionStatsTrendData[];
    direction: 'up' | 'down' | 'stable';
    correlation: number;
    seasonality: number;
    forecast: PermissionStatsTrendData[];
}
export interface PermissionStatsTrendData {
    date: Date;
    value: number;
    change?: number;
    changePercentage?: number;
    forecast?: boolean;
    confidence?: number;
}
export interface PermissionStatsPerformance {
    avgRequestTime: number;
    avgGrantTime: number;
    avgDenialTime: number;
    avgRationaleTime: number;
    avgSettingsTime: number;
    p50: number;
    p75: number;
    p90: number;
    p95: number;
    p99: number;
    slowestRequests: PermissionStatsSlowRequest[];
    fastestRequests: PermissionStatsFastRequest[];
}
export interface PermissionStatsSlowRequest {
    type: PermissionType;
    duration: number;
    timestamp: Date;
    status: PermissionStatus;
    rationale: boolean;
    settings: boolean;
    metadata?: Record<string, any>;
}
export interface PermissionStatsFastRequest {
    type: PermissionType;
    duration: number;
    timestamp: Date;
    status: PermissionStatus;
    fromCache: boolean;
    metadata?: Record<string, any>;
}
export interface PermissionStatsError {
    type: PermissionType;
    code: string;
    message: string;
    count: number;
    percentage: number;
    firstOccurrence: Date;
    lastOccurrence: Date;
    trend: 'up' | 'down' | 'stable';
    resolved: boolean;
    resolution?: string;
    impact: 'low' | 'medium' | 'high' | 'critical';
    suggestions: string[];
}
export interface PermissionCacheEntry {
    type: PermissionType;
    status: PermissionStatus;
    timestamp: Date;
    expiry: Date;
    deniedCount: number;
    requestCount: number;
    metadata?: Record<string, any>;
}
export interface PermissionCache {
    get(type: PermissionType): PermissionCacheEntry | null;
    set(type: PermissionType, entry: PermissionCacheEntry): void;
    remove(type: PermissionType): void;
    clear(): void;
    size(): number;
    keys(): PermissionType[];
    values(): PermissionCacheEntry[];
    entries(): [PermissionType, PermissionCacheEntry][];
    expired(type: PermissionType): boolean;
    prune(): void;
    stats(): PermissionCacheStats;
}
export interface PermissionCacheStats {
    size: number;
    hits: number;
    misses: number;
    hitRate: number;
    missRate: number;
    expired: number;
    evicted: number;
    memoryUsage: number;
    avgAge: number;
    maxAge: number;
    minAge: number;
}
export interface PermissionValidator {
    validate(type: PermissionType, options: PermissionRequestOptions): PermissionValidationResult;
    validateBatch(options: PermissionBatchRequestOptions): PermissionValidationResult;
    name: string;
    description?: string;
    config?: Record<string, any>;
}
export interface PermissionValidationResult {
    valid: boolean;
    errors: PermissionValidationError[];
    warnings: PermissionValidationWarning[];
    suggestions: PermissionValidationSuggestion[];
}
export interface PermissionValidationError {
    field: string;
    message: string;
    code: string;
    value: any;
    severity: 'error' | 'warning';
}
export interface PermissionValidationWarning {
    field: string;
    message: string;
    code: string;
    value: any;
    severity: 'low' | 'medium' | 'high';
}
export interface PermissionValidationSuggestion {
    field: string;
    message: string;
    code: string;
    suggestion: any;
    benefit: string;
    impact: 'low' | 'medium' | 'high';
}
export interface UsePermissionReturn {
    status: PermissionStatus;
    granted: boolean;
    denied: boolean;
    prompt: boolean;
    loading: boolean;
    error: PermissionError | null;
    check: () => Promise<PermissionCheckResult>;
    request: (options?: PermissionRequestOptions) => Promise<PermissionRequestResult>;
    openSettings: () => Promise<void>;
    clear: () => Promise<void>;
    refresh: () => Promise<void>;
}
export interface UsePermissionBatchReturn {
    results: Record<PermissionType, PermissionRequestResult>;
    allGranted: boolean;
    anyGranted: boolean;
    allDenied: boolean;
    anyDenied: boolean;
    loading: boolean;
    error: PermissionError | null;
    request: (options: PermissionBatchRequestOptions) => Promise<PermissionBatchRequestResult>;
    clear: () => Promise<void>;
    refresh: () => Promise<void>;
}
export type PermissionRequest = PermissionRequestOptions;
export type PermissionResult = PermissionRequestResult;
//# sourceMappingURL=permissions.d.ts.map