import { PSW_PASSTHROUGH_HEADER } from './constants/passthroughHeader.js';
export { PSW_PASSTHROUGH_HEADER };
export * from './constants/quotaMessages.js';
export declare const serviceWorkerErrorTypes: {
    readonly ERROR: "error";
    readonly INSTALL_ERROR: 'install_error';
    readonly ACTIVATE_ERROR: 'activate_error';
    readonly FETCH_ERROR: 'fetch_error';
    readonly MESSAGE_ERROR: "messageerror";
    readonly MESSAGE_ERROR_HANDLER: 'message_error_handler';
    readonly SYNC_ERROR: 'sync_error';
    readonly PERIODICSYNC_ERROR: 'periodicsync_error';
    readonly PUSH_ERROR: 'push_error';
    readonly BACKGROUNDFETCHSUCCESS_ERROR: 'backgroundfetchsuccess_error';
    readonly BACKGROUNDFETCHFAIL_ERROR: 'backgroundfetchfail_error';
    readonly BACKGROUNDFETCHABORT_ERROR: 'backgroundfetchabort_error';
    readonly BACKGROUNDFETCHCLICK_ERROR: 'backgroundfetchclick_error';
    readonly REJECTION_HANDLED: "rejectionhandled";
    readonly UNHANDLED_REJECTION: "unhandledrejection";
};
export type ServiceWorkerErrorType = (typeof serviceWorkerErrorTypes)[keyof typeof serviceWorkerErrorTypes];
interface SyncEvent extends ExtendableEvent {
    readonly tag: string;
    readonly lastChance: boolean;
}
interface PeriodicSyncEvent extends ExtendableEvent {
    readonly tag: string;
}
declare global {
    interface ServiceWorkerGlobalScopeEventMap {
        sync: SyncEvent;
        periodicsync: PeriodicSyncEvent;
        backgroundfetchsuccess: BackgroundFetchUpdateUIEvent;
        backgroundfetchfail: BackgroundFetchUpdateUIEvent;
        backgroundfetchabort: BackgroundFetchEvent;
        backgroundfetchclick: BackgroundFetchEvent;
    }
}
export interface SwMessageEvent extends Omit<ExtendableMessageEvent, 'data'> {
    data: {
        type: string;
    };
}
export interface Logger {
    trace: (...data: unknown[]) => void;
    debug: (...data: unknown[]) => void;
    info: (...data: unknown[]) => void;
    warn: (...data: unknown[]) => void;
    error: (...data: unknown[]) => void;
}
export interface PluginContext {
    logger: Logger;
    base?: string;
    passthroughHeader: string;
    fetchPassthrough: (request: Request) => Promise<Response>;
}
export interface ServiceWorkerInitOptions {
    version: string;
    base?: string;
    logger?: Logger;
    debug?: boolean;
    logFetchInDebug?: boolean;
    pingPath?: string;
    passthroughRequestHeader?: string;
    onError?: (error: Error | unknown, event: Event, errorType?: ServiceWorkerErrorType) => void;
}
export type PushNotificationPayload = {
    title: string;
} & NotificationOptions;
export declare function __resetServiceWorkerState(): void;
export type ContextOfPlugin<P> = P extends ServiceWorkerPlugin<infer C> ? C : PluginContext;
export type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
type CleanPluginContext<C> = C extends PluginContext ? Omit<C, 'fetchPassthrough' | 'passthroughHeader' | 'logger'> & {
    logger?: Logger;
} : C;
export type RequiredOptions<P extends readonly unknown[]> = UnionToIntersection<CleanPluginContext<ContextOfPlugin<P[number]>>>;
interface ServiceWorkerEventHandlers {
    install?: (event: ExtendableEvent, context: PluginContext) => void | Promise<void>;
    activate?: (event: ExtendableEvent, context: PluginContext) => void | Promise<void>;
    fetch?: (event: FetchEvent, context: PluginContext) => Promise<Response | undefined>;
    message?: (event: SwMessageEvent, context: PluginContext) => void | Promise<void>;
    sync?: (event: SyncEvent, context: PluginContext) => Promise<void>;
    periodicsync?: (event: PeriodicSyncEvent, context: PluginContext) => Promise<void>;
    push?: (event: PushEvent, context: PluginContext) => void | PushNotificationPayload | false | Promise<void | PushNotificationPayload | false>;
    backgroundfetchsuccess?: (event: BackgroundFetchUpdateUIEvent, context: PluginContext) => void | Promise<void>;
    backgroundfetchfail?: (event: BackgroundFetchUpdateUIEvent, context: PluginContext) => void | Promise<void>;
    backgroundfetchabort?: (event: BackgroundFetchEvent, context: PluginContext) => void | Promise<void>;
    backgroundfetchclick?: (event: BackgroundFetchEvent, context: PluginContext) => void | Promise<void>;
}
export interface ServiceWorkerPlugin<_C extends PluginContext = PluginContext> extends ServiceWorkerEventHandlers {
    name: string;
    order?: number;
}
export type Plugin = ServiceWorkerPlugin<PluginContext>;
export type FetchResponse = Promise<Response | undefined>;
export interface CreateEventHandlersResult {
    install?: (event: ExtendableEvent) => void;
    activate?: (event: ExtendableEvent) => void;
    fetch?: (event: FetchEvent) => void;
    message?: (event: SwMessageEvent) => void;
    sync?: (event: SyncEvent) => void;
    periodicsync?: (event: PeriodicSyncEvent) => void;
    push?: (event: PushEvent) => void;
    backgroundfetchsuccess?: (event: BackgroundFetchUpdateUIEvent) => void;
    backgroundfetchfail?: (event: BackgroundFetchUpdateUIEvent) => void;
    backgroundfetchabort?: (event: BackgroundFetchEvent) => void;
    backgroundfetchclick?: (event: BackgroundFetchEvent) => void;
    error: (event: ErrorEvent) => void;
    messageerror: (event: MessageEvent) => void;
    unhandledrejection: (event: PromiseRejectionEvent) => void;
    rejectionhandled: (event: PromiseRejectionEvent) => void;
}
export declare function createEventHandlers<_C extends PluginContext = PluginContext>(plugins: readonly ServiceWorkerPlugin<_C>[], options: ServiceWorkerInitOptions & CleanPluginContext<_C>): CreateEventHandlersResult;
export declare function initServiceWorker<P extends readonly unknown[]>(plugins: P, options: RequiredOptions<P> & ServiceWorkerInitOptions): void;