@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/types/wallet/wallet.d.ts

@@ -4,17 +4,20 @@ import { ArkAddress } from "../script/address";
 import { DefaultVtxo } from "../script/default";
 import { Network, NetworkName } from "../networks";
 import { OnchainProvider } from "../providers/onchain";
-import { SettlementEvent, ArkProvider, SignedIntent } from "../providers/ark";
+import { ArkProvider, SettlementEvent, SignedIntent } from "../providers/ark";
 import { SignerSession } from "../tree/signingSession";
 import { Identity, ReadonlyIdentity } from "../identity";
-import { ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter, IReadonlyWallet, IWallet, ReadonlyWalletConfig, SendBitcoinParams, SettleParams, VirtualCoin, WalletBalance, WalletConfig } from ".";
-import { TapLeafScript } from "../script/base";
+import { ArkTransaction, Recipient, Coin, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter, IReadonlyWallet, IWallet, ReadonlyWalletConfig, SendBitcoinParams, SettleParams, VirtualCoin, WalletBalance, WalletConfig, IAssetManager, IReadonlyAssetManager } from ".";
 import { CSVMultisigTapscript } from "../script/tapscript";
 import { Intent } from "../intent";
 import { IndexerProvider } from "../providers/indexer";
-import { WalletRepository, WalletRepositoryImpl } from "../repositories/walletRepository";
-import { ContractRepository, ContractRepositoryImpl } from "../repositories/contractRepository";
+import { WalletRepository } from "../repositories/walletRepository";
+import { ContractRepository } from "../repositories/contractRepository";
 import { Batch } from "./batch";
+import { DelegatorProvider } from "../providers/delegator";
+import { DelegateVtxo } from "../script/delegate";
+import { DelegatorManager } from "./delegator";
+import { ContractManager } from "../contracts/contractManager";
 export type IncomingFunds = {
     type: "utxo";
     coins: Coin[];
@@ -29,32 +32,44 @@ export declare class ReadonlyWallet implements IReadonlyWallet {
     readonly onchainProvider: OnchainProvider;
     readonly indexerProvider: IndexerProvider;
     readonly arkServerPublicKey: Bytes;
-    readonly offchainTapscript: DefaultVtxo.Script;
+    readonly offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script;
     readonly boardingTapscript: DefaultVtxo.Script;
     readonly dustAmount: bigint;
     readonly walletRepository: WalletRepository;
     readonly contractRepository: ContractRepository;
-    protected constructor(identity: ReadonlyIdentity, network: Network, onchainProvider: OnchainProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script, boardingTapscript: DefaultVtxo.Script, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository);
+    readonly delegatorProvider?: DelegatorProvider | undefined;
+    private _contractManager?;
+    private _contractManagerInitializing?;
+    protected readonly watcherConfig?: ReadonlyWalletConfig["watcherConfig"];
+    private readonly _assetManager;
+    get assetManager(): IReadonlyAssetManager;
+    protected constructor(identity: ReadonlyIdentity, network: Network, onchainProvider: OnchainProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script, boardingTapscript: DefaultVtxo.Script, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository, delegatorProvider?: DelegatorProvider | undefined, watcherConfig?: ReadonlyWalletConfig["watcherConfig"]);
     /**
      * Protected helper to set up shared wallet configuration.
      * Extracts common logic used by both ReadonlyWallet.create() and Wallet.create().
      */
-    protected static setupWalletConfig(config: ReadonlyWalletConfig, pubkey: Uint8Array): Promise<{
+    protected static setupWalletConfig(config: ReadonlyWalletConfig, pubKey: Uint8Array): Promise<{
         arkProvider: ArkProvider;
         indexerProvider: IndexerProvider;
         onchainProvider: OnchainProvider;
         network: Network;
         networkName: NetworkName;
         serverPubKey: Uint8Array<ArrayBuffer>;
-        offchainTapscript: DefaultVtxo.Script;
+        offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script;
         boardingTapscript: DefaultVtxo.Script;
         dustAmount: bigint;
-        walletRepository: WalletRepositoryImpl;
-        contractRepository: ContractRepositoryImpl;
+        walletRepository: WalletRepository;
+        contractRepository: ContractRepository;
         info: import("../providers/ark").ArkInfo;
+        delegatorProvider: DelegatorProvider | undefined;
     }>;
     static create(config: ReadonlyWalletConfig): Promise<ReadonlyWallet>;
     get arkAddress(): ArkAddress;
+    /**
+     * Get the contract script for the wallet's default address.
+     * This is the pkScript hex, used to identify the wallet in ContractManager.
+     */
+    get defaultContractScript(): string;
     getAddress(): Promise<string>;
     getBoardingAddress(): Promise<string>;
     getBalance(): Promise<WalletBalance>;
@@ -68,6 +83,46 @@ export declare class ReadonlyWallet implements IReadonlyWallet {
     getBoardingUtxos(): Promise<ExtendedCoin[]>;
     notifyIncomingFunds(eventCallback: (coins: IncomingFunds) => void): Promise<() => void>;
     fetchPendingTxs(): Promise<string[]>;
+    /**
+     * Get all pkScript hex strings for the wallet's own addresses
+     * (both delegate and non-delegate, current and historical).
+     * Falls back to only the current script if ContractManager is not yet initialized.
+     */
+    getWalletScripts(): Promise<string[]>;
+    /**
+     * Build a map of scriptHex → VtxoScript for all wallet contracts,
+     * so VTXOs can be extended with the correct tapscript per contract.
+     */
+    getScriptMap(): Promise<Map<string, DefaultVtxo.Script | DelegateVtxo.Script>>;
+    /**
+     * Get the ContractManager for managing contracts including the wallet's default address.
+     *
+     * The ContractManager handles:
+     * - The wallet's default receiving address (as a "default" contract)
+     * - External contracts (Boltz swaps, HTLCs, etc.)
+     * - Multi-contract watching with resilient connections
+     *
+     * @example
+     * ```typescript
+     * const manager = await wallet.getContractManager();
+     *
+     * // Create a contract for a Boltz swap
+     * const contract = await manager.createContract({
+     *   label: "Boltz Swap",
+     *   type: "vhtlc",
+     *   params: { ... },
+     *   script: swapScript,
+     *   address: swapAddress,
+     * });
+     *
+     * // Start watching for events (includes wallet's default address)
+     * const stop = await manager.onContractEvent((event) => {
+     *   console.log(`${event.type} on ${event.contractScript}`);
+     * });
+     * ```
+     */
+    getContractManager(): Promise<ContractManager>;
+    private initializeContractManager;
 }
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
@@ -110,11 +165,14 @@ export declare class Wallet extends ReadonlyWallet implements IWallet {
     readonly forfeitPubkey: Bytes;
     static MIN_FEE_RATE: number;
     readonly identity: Identity;
+    readonly delegatorManager?: DelegatorManager;
+    private _walletAssetManager?;
     readonly renewalConfig: Required<Omit<WalletConfig["renewalConfig"], "enabled">> & {
         enabled: boolean;
         thresholdMs: number;
     };
-    protected constructor(identity: Identity, network: Network, networkName: NetworkName, onchainProvider: OnchainProvider, arkProvider: ArkProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script, boardingTapscript: DefaultVtxo.Script, serverUnrollScript: CSVMultisigTapscript.Type, forfeitOutputScript: Bytes, forfeitPubkey: Bytes, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository, renewalConfig?: WalletConfig["renewalConfig"]);
+    protected constructor(identity: Identity, network: Network, networkName: NetworkName, onchainProvider: OnchainProvider, arkProvider: ArkProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script, boardingTapscript: DefaultVtxo.Script, serverUnrollScript: CSVMultisigTapscript.Type, forfeitOutputScript: Bytes, forfeitPubkey: Bytes, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository, renewalConfig?: WalletConfig["renewalConfig"], delegatorProvider?: DelegatorProvider, watcherConfig?: WalletConfig["watcherConfig"]);
+    get assetManager(): IAssetManager;
     static create(config: WalletConfig): Promise<Wallet>;
     /**
      * Convert this wallet to a readonly wallet.
@@ -142,12 +200,13 @@ export declare class Wallet extends ReadonlyWallet implements IWallet {
      * @param intentId - The intent ID.
      * @param inputs - The inputs of the intent.
      * @param session - The musig2 signing session, if not provided, the signing will be skipped.
+     * @param expectedRecipients - Expected recipients to validate in the vtxo tree.
      */
-    createBatchHandler(intentId: string, inputs: ExtendedCoin[], session?: SignerSession): Batch.Handler;
+    createBatchHandler(intentId: string, inputs: ExtendedCoin[], expectedRecipients: Recipient[], session?: SignerSession): Batch.Handler;
     safeRegisterIntent(intent: SignedIntent<Intent.RegisterMessage>): Promise<string>;
-    makeRegisterIntentSignature(coins: ExtendedCoin[], outputs: TransactionOutput[], onchainOutputsIndexes: number[], cosignerPubKeys: string[]): Promise<SignedIntent<Intent.RegisterMessage>>;
+    makeRegisterIntentSignature(coins: ExtendedCoin[], outputs: TransactionOutput[], onchainOutputsIndexes: number[], cosignerPubKeys: string[], validAt?: number): Promise<SignedIntent<Intent.RegisterMessage>>;
     makeDeleteIntentSignature(coins: ExtendedCoin[]): Promise<SignedIntent<Intent.DeleteMessage>>;
-    makeGetPendingTxIntentSignature(vtxos: ExtendedVirtualCoin[]): Promise<SignedIntent<Intent.GetPendingTxMessage>>;
+    makeGetPendingTxIntentSignature(coins: ExtendedVirtualCoin[]): Promise<SignedIntent<Intent.GetPendingTxMessage>>;
     /**
      * Finalizes pending transactions by retrieving them from the server and finalizing each one.
      * @param vtxos - Optional list of VTXOs to use instead of retrieving them from the server
@@ -157,9 +216,44 @@ export declare class Wallet extends ReadonlyWallet implements IWallet {
         finalized: string[];
         pending: string[];
     }>;
-    private prepareIntentProofInputs;
+    /**
+     * Send BTC and/or assets to one or more recipients.
+     *
+     * @param recipients - Array of recipients with their addresses, BTC amounts, and assets
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.send({
+     *     address: 'ark1...',
+     *     amount: 1000, // (optional, default to dust) btc amount to send to the output
+     *     assets: [{ assetId: 'abc123...', amount: 50 }] // (optional) list of assets to send
+     * });
+     * ```
+     */
+    send(...args: Recipient[]): Promise<string>;
+    /**
+     * Build an offchain transaction from the given inputs and outputs,
+     * sign it, submit to the ark provider, and finalize.
+     * @returns The ark transaction id and server-signed checkpoint PSBTs (for bookkeeping)
+     */
+    buildAndSubmitOffchainTx(inputs: VirtualCoin[], outputs: TransactionOutput[]): Promise<{
+        arkTxid: string;
+        signedCheckpointTxs: string[];
+    }>;
+    private updateDbAfterOffchainTx;
+    private updateDbAfterSettle;
 }
-export declare function getSequence(tapLeafScript: TapLeafScript): number | undefined;
+/**
+ * Select virtual coins to reach a target amount, prioritizing those closer to expiry
+ * @param coins List of virtual coins to select from
+ * @param targetAmount Target amount to reach in satoshis
+ * @returns Selected coins and change amount
+ */
+export declare function selectVirtualCoins(coins: VirtualCoin[], targetAmount: number): {
+    inputs: VirtualCoin[];
+    changeAmount: bigint;
+};
 /**
  * Wait for incoming funds to the wallet
  * @param wallet - The wallet to wait for incoming funds

package/dist/types/worker/browser/service-worker-manager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Registers a service worker for the given path only once and caches the
+ * registration promise for subsequent calls.
+ *
+ * @param path - Service worker script path to register.
+ * @throws if service workers are not supported or registration fails.
+ */
+export declare function setupServiceWorkerOnce(path: string): Promise<ServiceWorkerRegistration>;
+/**
+ * Returns an active service worker instance, optionally ensuring a specific
+ * script path is registered before resolving.
+ *
+ * @param path - Optional service worker script path to register and prefer.
+ * @throws if service workers are not supported or no active worker is available.
+ */
+export declare function getActiveServiceWorker(path?: string): Promise<ServiceWorker>;
+/**
+ * Clears the cached registration promises.
+ * Intended for tests to reset state between runs.
+ */
+export declare const __resetServiceWorkerManager: () => void;

package/dist/types/{wallet/serviceWorker → worker/browser}/utils.d.ts

@@ -2,9 +2,10 @@ export declare const DEFAULT_DB_NAME = "arkade-service-worker";
 /**
  * setupServiceWorker sets up the service worker.
  * @param path - the path to the service worker script
+ * @throws if service workers are not supported or activation fails
  * @example
  * ```typescript
- * const serviceWorker = await setupServiceWorker("/service-worker.js");
+ * const worker = await setupServiceWorker("/service-worker.js");
  * ```
  */
 export declare function setupServiceWorker(path: string): Promise<ServiceWorker>;

package/dist/types/worker/expo/asyncStorageTaskQueue.d.ts

@@ -0,0 +1,46 @@
+import type { TaskItem, TaskResult, TaskQueue } from "./taskQueue";
+/**
+ * Minimal async key-value storage interface.
+ *
+ * Compatible with `@react-native-async-storage/async-storage` and
+ * any other storage that exposes the same three methods.
+ */
+export interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+/**
+ * AsyncStorage-backed TaskQueue for Expo/React Native.
+ *
+ * Persists inbox, outbox, and an optional config blob to AsyncStorage
+ * so that data survives process restarts and can be shared between
+ * foreground and background execution contexts.
+ */
+export declare class AsyncStorageTaskQueue implements TaskQueue {
+    private readonly storage;
+    private readonly inboxKey;
+    private readonly outboxKey;
+    private readonly configKey;
+    constructor(storage: AsyncStorageLike, prefix?: string);
+    addTask(task: TaskItem): Promise<void>;
+    removeTask(id: string): Promise<void>;
+    getTasks(type?: string): Promise<TaskItem[]>;
+    clearTasks(): Promise<void>;
+    pushResult(result: TaskResult): Promise<void>;
+    getResults(): Promise<TaskResult[]>;
+    acknowledgeResults(ids: string[]): Promise<void>;
+    /**
+     * Persist a config blob alongside the queue data.
+     * Used by {@link ExpoWallet.setup} to store the wallet parameters
+     * that the background handler needs to reconstruct providers.
+     */
+    persistConfig(config: Record<string, unknown> | object): Promise<void>;
+    /**
+     * Load the persisted config blob.
+     * Used by the background handler to rehydrate wallet dependencies.
+     */
+    loadConfig<T = Record<string, unknown>>(): Promise<T | null>;
+    private readList;
+    private writeList;
+}

package/dist/types/worker/expo/index.d.ts

@@ -0,0 +1,7 @@
+export type { TaskItem, TaskResult, TaskQueue } from "./taskQueue";
+export { InMemoryTaskQueue } from "./taskQueue";
+export type { AsyncStorageLike } from "./asyncStorageTaskQueue";
+export { AsyncStorageTaskQueue } from "./asyncStorageTaskQueue";
+export type { TaskProcessor, TaskDependencies } from "./taskRunner";
+export { runTasks } from "./taskRunner";
+export { contractPollProcessor, CONTRACT_POLL_TASK_TYPE } from "./processors";

package/dist/types/worker/expo/processors/contractPollProcessor.d.ts

@@ -0,0 +1,14 @@
+import type { TaskProcessor } from "../taskRunner";
+export declare const CONTRACT_POLL_TASK_TYPE = "contract-poll";
+/**
+ * Polls the indexer for the latest VTXO state of every contract and
+ * persists the results to the wallet repository.
+ *
+ * Replicates the polling subset of {@link ContractManager.initialize}:
+ * 1. Load all contracts from the contract repository.
+ * 2. Mark expired active contracts as inactive.
+ * 3. Paginated fetch of spendable VTXOs from the indexer.
+ * 4. Extend each VTXO with tapscript data.
+ * 5. Save to the wallet repository.
+ */
+export declare const contractPollProcessor: TaskProcessor;

package/dist/types/worker/expo/processors/index.d.ts

@@ -0,0 +1 @@
+export { contractPollProcessor, CONTRACT_POLL_TASK_TYPE, } from "./contractPollProcessor";

package/dist/types/worker/expo/taskQueue.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A task item represents a unit of work in the inbox.
+ */
+export interface TaskItem {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    createdAt: number;
+}
+/**
+ * A task result represents the outcome of processing a task item.
+ */
+export interface TaskResult {
+    id: string;
+    taskItemId: string;
+    type: string;
+    status: "success" | "failed" | "noop";
+    data?: Record<string, unknown>;
+    executedAt: number;
+}
+/**
+ * Persistence layer for handing off work between foreground and background.
+ *
+ * - **Inbox**: tasks waiting to be processed.
+ * - **Outbox**: results produced by processors, waiting to be consumed.
+ */
+export interface TaskQueue {
+    addTask(task: TaskItem): Promise<void>;
+    removeTask(id: string): Promise<void>;
+    getTasks(type?: string): Promise<TaskItem[]>;
+    clearTasks(): Promise<void>;
+    pushResult(result: TaskResult): Promise<void>;
+    getResults(): Promise<TaskResult[]>;
+    acknowledgeResults(ids: string[]): Promise<void>;
+}
+/**
+ * In-memory TaskQueue for testing and lightweight use.
+ * State is lost when the process exits.
+ */
+export declare class InMemoryTaskQueue implements TaskQueue {
+    private inbox;
+    private outbox;
+    addTask(task: TaskItem): Promise<void>;
+    removeTask(id: string): Promise<void>;
+    getTasks(type?: string): Promise<TaskItem[]>;
+    clearTasks(): Promise<void>;
+    pushResult(result: TaskResult): Promise<void>;
+    getResults(): Promise<TaskResult[]>;
+    acknowledgeResults(ids: string[]): Promise<void>;
+}

package/dist/types/worker/expo/taskRunner.d.ts

@@ -0,0 +1,42 @@
+import type { TaskItem, TaskResult, TaskQueue } from "./taskQueue";
+import type { WalletRepository } from "../../repositories/walletRepository";
+import type { ContractRepository } from "../../repositories/contractRepository";
+import type { IndexerProvider } from "../../providers/indexer";
+import type { ArkProvider } from "../../providers/ark";
+import type { ExtendedVirtualCoin, VirtualCoin } from "../../wallet";
+import type { Contract } from "../../contracts/types";
+/**
+ * Shared dependencies injected into every processor at runtime.
+ */
+export interface TaskDependencies {
+    walletRepository: WalletRepository;
+    contractRepository: ContractRepository;
+    indexerProvider: IndexerProvider;
+    arkProvider: ArkProvider;
+    extendVtxo: (vtxo: VirtualCoin, contract?: Contract) => ExtendedVirtualCoin;
+}
+/**
+ * A stateless unit that handles one type of task item.
+ *
+ * Processors must not keep in-memory state across invocations —
+ * all coordination lives in the {@link TaskQueue} and repositories.
+ *
+ * The `TDeps` parameter defaults to {@link TaskDependencies} but
+ * can be overridden for domain-specific processors (e.g. swap processing).
+ */
+export interface TaskProcessor<TDeps = TaskDependencies> {
+    readonly taskType: string;
+    execute(item: TaskItem, deps: TDeps): Promise<Omit<TaskResult, "id" | "executedAt">>;
+}
+/**
+ * Run all pending tasks from the queue through matching processors.
+ *
+ * For each task in the inbox:
+ * 1. Find the processor whose `taskType` matches `task.type`.
+ * 2. Execute it, producing a {@link TaskResult}.
+ * 3. Push the result to the outbox and remove the task from the inbox.
+ *
+ * Tasks with no matching processor produce a `"noop"` result.
+ * Processor errors produce a `"failed"` result with the error message.
+ */
+export declare function runTasks<TDeps = TaskDependencies>(queue: TaskQueue, processors: TaskProcessor<TDeps>[], deps: TDeps): Promise<TaskResult[]>;

package/dist/types/worker/messageBus.d.ts

@@ -0,0 +1,109 @@
+import { ArkProvider } from "../providers/ark";
+import { ReadonlyWallet, Wallet } from "../wallet/wallet";
+import { ContractRepository, WalletRepository } from "../repositories";
+export type RequestEnvelope = {
+    tag: string;
+    id: string;
+    broadcast?: boolean;
+};
+export type ResponseEnvelope = {
+    tag: string;
+    id?: string;
+    error?: Error;
+    broadcast?: boolean;
+};
+export interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, RES extends ResponseEnvelope = ResponseEnvelope> {
+    /**
+     * A unique identifier for the updater.
+     * This is used to route messages to the correct updater.
+     */
+    readonly messageTag: string;
+    /**
+     * Called once when the SW is starting up
+     * @param opts.arkProvider
+     * @param opts.wallet Wallet with signature cababilities
+     * @param opts.readonlyWallet Read-only Wallet
+     **/
+    start(services: {
+        arkProvider: ArkProvider;
+        wallet?: Wallet;
+        readonlyWallet: ReadonlyWallet;
+    }, repositories: {
+        walletRepository: WalletRepository;
+    }): Promise<void>;
+    /** Called once when the SW is shutting down */
+    stop(): Promise<void>;
+    /**
+     * Called by the scheduler to perform a tick.
+     * Can be used by the updater to perform periodic tasks or return
+     * delayed responses (eg: subscriptions).
+     * @param now The current time in milliseconds since the epoch.
+     **/
+    tick(now: number): Promise<RES[]>;
+    /**
+     * Handle routed messages from the clients
+     **/
+    handleMessage(message: REQ): Promise<RES | null>;
+}
+type Options = {
+    messageHandlers: MessageHandler[];
+    tickIntervalMs?: number;
+    debug?: boolean;
+    buildServices?: (config: Initialize["config"]) => Promise<{
+        arkProvider: ArkProvider;
+        wallet?: Wallet;
+        readonlyWallet: ReadonlyWallet;
+    }>;
+};
+type Initialize = {
+    type: "INITIALIZE_MESSAGE_BUS";
+    id: string;
+    config: {
+        wallet: {
+            privateKey: string;
+        } | {
+            publicKey: string;
+        };
+        arkServer: {
+            url: string;
+            publicKey?: string;
+        };
+    };
+};
+export declare class MessageBus {
+    private readonly walletRepository;
+    private readonly contractRepository;
+    private handlers;
+    private tickIntervalMs;
+    private running;
+    private tickTimeout;
+    private tickInProgress;
+    private debug;
+    private initialized;
+    private readonly buildServicesFn;
+    constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, debug, buildServices, }: Options);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private scheduleNextTick;
+    private runTick;
+    private waitForInit;
+    private buildServices;
+    private onMessage;
+    /**
+     * Returns the registered SW for the path.
+     * It uses the functions in `service-worker-manager.ts` module.
+     * @param path
+     * @return the Service Worker
+     * @throws if not running in a browser environment
+     */
+    static getServiceWorker(path?: string): Promise<ServiceWorker>;
+    /**
+     * Set up and register the Service Worker, ensuring it's done once at most.
+     * It uses the functions in `service-worker-manager.ts` module.
+     * @param path
+     * @return the Service Worker
+     * @throws if not running in a browser environment
+     */
+    static setup(path: string): Promise<ServiceWorker>;
+}
+export {};