@mdbase-dev/connect 0.1.0-beta.30 → 0.1.0-beta.32

package/dist/connect.js

@@ -1,13 +1,15 @@
-import { APPLICATION_AUTHORIZATION_PROTOCOL_VERSION, DEFAULT_LOOPBACK_PORT, ENCRYPTED_RELAY_PROTOCOL_VERSION, RELAY_ENCRYPTION_SUITE } from "@mdbase-dev/connect-protocol";
+import { APPLICATION_AUTHORIZATION_PROTOCOL_VERSION, authorizationContractRequirements, DEFAULT_LOOPBACK_PORT, GRANT_ENCRYPTION_PROTOCOL_VERSION, RELAY_ENCRYPTION_SUITE } from "@mdbase-dev/connect-protocol";
 import { abortableDelay } from "./async.js";
 import { randomBase64Url } from "./base64.js";
 import { ApplicationIdentityStoreError, IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, applicationIdentity, applicationInstallationId, signApplicationAuthorization } from "./application-identity.js";
 import { MdbaseConnection } from "./connection.js";
-import { IndexedDbGrantKeyStore, MemoryGrantKeyStore, validateGrantEncryption } from "./crypto.js";
-import { connectError, serverConnectError } from "./errors.js";
+import { IndexedDbGrantKeyStore, MemoryGrantKeyStore } from "./crypto.js";
+import { MdbaseConnectError, connectError, serverConnectError } from "./errors.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { uniqueOperations } from "./operation-helpers.js";
-import { MemoryStorage, apiError, applicationStorageOrigin, canonicalLoopbackUrl, collectionIdFromTokenKey, connectFetch, createPkce, defaultManifestSource, defaultRedirectUri, defaultStorage, isOpaquePortableManifest, manifestStorageFingerprint, oauthErrorCode, parseDeviceAuthorization, parseGrantScope, parseStored, stripTrailingSlash, validFileCapability, validAuthorityTokenResponse } from "./runtime-utils.js";
+import { resolveConnectTimeouts, withRequestBudget } from "./request-budget.js";
+import { MemoryStorage, apiError, applicationStorageOrigin, canonicalLoopbackUrl, collectionIdFromTokenKey, connectFetch, createPkce, defaultManifestSource, defaultRedirectUri, defaultStorage, decodeJsonResponse, isOpaquePortableManifest, manifestStorageFingerprint, oauthErrorCode, parseDeviceAuthorization, parseStored, stripTrailingSlash, validAuthorityTokenResponse } from "./runtime-utils.js";
+import { storedTokenFromResponse } from "./token-response.js";
 export class MdbaseConnectInternals {
     serverUrl;
     manifest;
@@ -20,6 +22,7 @@ export class MdbaseConnectInternals {
     directAccessMode;
     loopbackUrl;
     navigate;
+    timeouts;
     credentialStorage;
     application = null;
     manifestPromise = null;
@@ -28,17 +31,19 @@ export class MdbaseConnectInternals {
     listeners = new Set();
     invalidatedConnections = new Map();
     constructor(options) {
-        this.serverUrl = stripTrailingSlash(options.serverUrl);
-        this.manifest = options.manifest ?? defaultManifestSource();
+        this.serverUrl = stripTrailingSlash(String(options.serverUrl));
+        this.manifest = options.manifest instanceof URL
+            ? options.manifest.href
+            : options.manifest ?? defaultManifestSource();
         this.manifestSource = typeof this.manifest === "string"
             ? this.manifest
             : this.manifest.distribution === "portable"
                 ? `bundle:${this.manifest.id}:${manifestStorageFingerprint(this.manifest)}`
                 : `bundle:${this.manifest.id}`;
         const opaquePortable = isOpaquePortableManifest(this.manifest);
-        this.redirectUri = options.redirectUri ?? (typeof this.manifest !== "string" && this.manifest.distribution === "portable"
+        this.redirectUri = options.redirectUri === undefined ? (typeof this.manifest !== "string" && this.manifest.distribution === "portable"
             ? ""
-            : defaultRedirectUri());
+            : defaultRedirectUri()) : String(options.redirectUri);
         this.storage = options.storage ?? defaultStorage(opaquePortable);
         this.relayEncryption = options.relayEncryption ?? "required";
         this.keyStore = options.keyStore ?? (opaquePortable ? new MemoryGrantKeyStore() : new IndexedDbGrantKeyStore());
@@ -49,8 +54,9 @@ export class MdbaseConnectInternals {
             ? "custom"
             : this.storage instanceof MemoryStorage ? "memory" : "persistent";
         this.directAccessMode = options.directAccess ?? "auto";
-        this.loopbackUrl = canonicalLoopbackUrl(options.loopbackUrl ?? `http://127.0.0.1:${DEFAULT_LOOPBACK_PORT}`);
+        this.loopbackUrl = canonicalLoopbackUrl(String(options.loopbackUrl ?? `http://127.0.0.1:${DEFAULT_LOOPBACK_PORT}`));
         this.navigate = options.navigate;
+        this.timeouts = resolveConnectTimeouts(options.timeouts);
         if (typeof window !== "undefined" && this.storage === window.localStorage) {
             window.addEventListener("storage", (event) => {
                 if (event.storageArea !== this.storage || !event.key?.startsWith(this.storagePrefix()))
@@ -73,34 +79,45 @@ export class MdbaseConnectInternals {
             credentialStorage: this.credentialStorage
         };
     }
-    async register() {
+    register(options = {}) {
+        return withRequestBudget(options, this.timeouts.requestMs, (budget) => this.registerWithinBudget(budget.signal));
+    }
+    async registerWithinBudget(signal) {
         if (this.application)
             return this.application;
         const response = await connectFetch(`${this.serverUrl}/v1/apps/register`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ manifest: await this.manifestDeclaration() })
+            body: JSON.stringify({ manifest: await this.manifestDeclaration({ signal, timeoutMs: null }) }),
+            signal
         }, "temporarily_unavailable", "Application registration is temporarily unavailable.");
-        const body = await response.json();
+        const body = await decodeJsonResponse(response, "invalid_operation_response", "Connect returned an invalid application registration response.");
         if (!response.ok)
             throw apiError(body, "discovery_failed", "Application discovery failed.", response.status);
         this.application = body.application;
         return this.application;
     }
-    manifestDeclaration() {
+    manifestDeclaration(options = {}) {
         if (this.manifestPromise)
             return this.manifestPromise;
-        this.manifestPromise = this.loadManifest();
+        const loading = withRequestBudget(options, this.timeouts.requestMs, (budget) => this.loadManifest(budget.signal));
+        const shared = loading.catch((error) => {
+            if (this.manifestPromise === shared)
+                this.manifestPromise = null;
+            throw error;
+        });
+        this.manifestPromise = shared;
         return this.manifestPromise;
     }
-    async loadManifest() {
+    async loadManifest(signal) {
         if (typeof this.manifest !== "string")
             return this.manifest;
         const source = this.manifest;
         let response;
         try {
             response = await fetch(source, {
-                headers: { accept: "application/json" }
+                headers: { accept: "application/json" },
+                signal
             });
         }
         catch (cause) {
@@ -110,7 +127,7 @@ export class MdbaseConnectInternals {
             throw connectError("manifest_load_failed", `The bundled application declaration returned HTTP ${response.status}.`, { status: response.status });
         }
         try {
-            return await response.json();
+            return await decodeJsonResponse(response, "invalid_application_manifest", "The bundled application declaration is not valid JSON.");
         }
         catch (cause) {
             throw connectError("invalid_application_manifest", "The bundled application declaration is not valid JSON.", {
@@ -127,6 +144,9 @@ export class MdbaseConnectInternals {
         }
     }
     async authorize(options = {}) {
+        return withRequestBudget(options, this.timeouts.requestMs, (budget) => this.authorizeWithinBudget({ ...options, signal: budget.signal, timeoutMs: null }));
+    }
+    async authorizeWithinBudget(options) {
         if (typeof location === "undefined" && !this.navigate && !options.openVerification) {
             throw connectError("browser_required", "Authorization navigation requires a browser environment.");
         }
@@ -140,7 +160,7 @@ export class MdbaseConnectInternals {
             : null;
         let application;
         try {
-            application = await this.register();
+            application = await this.registerWithinBudget(options.signal);
         }
         catch (error) {
             popup?.close();
@@ -189,6 +209,7 @@ export class MdbaseConnectInternals {
             redirect_uri: this.redirectUri,
             state,
             code_challenge: challenge,
+            contracts: authorizationContractRequirements(operations, application.requirements?.files),
             requested_operations: operations,
             ...(application.requirements?.files
                 ? { requested_files: application.requirements.files }
@@ -226,7 +247,7 @@ export class MdbaseConnectInternals {
                 }),
                 signal: options.signal
             });
-            const body = await response.json();
+            const body = await decodeJsonResponse(response, "invalid_device_authorization_response", "The authorization service returned an invalid authorization response.");
             if (!response.ok) {
                 throw apiError(body, "device_authorization_failed", "Application authorization could not be started.", response.status);
             }
@@ -249,7 +270,7 @@ export class MdbaseConnectInternals {
             this.storage.removeItem(this.pendingKey(state));
             await this.keyStore.delete(keyHandle);
             if (options.signal?.aborted) {
-                throw connectError("authorization_cancelled", "Application authorization was cancelled.", { cause: error });
+                throw authorizationAbort(options.signal, "Application authorization was cancelled.", error);
             }
             throw error;
         }
@@ -288,6 +309,7 @@ export class MdbaseConnectInternals {
             issued_at: issuedAt.toISOString(),
             expires_at: new Date(issuedAt.getTime() + 10 * 60 * 1_000).toISOString(),
             code_challenge: challenge,
+            contracts: authorizationContractRequirements(operations, application.requirements?.files),
             requested_operations: operations,
             ...(application.requirements?.files
                 ? { requested_files: application.requirements.files }
@@ -311,9 +333,10 @@ export class MdbaseConnectInternals {
                     code_challenge: challenge,
                     code_challenge_method: "S256",
                     application_authorization: JSON.stringify(proof)
-                })
+                }),
+                signal: options.signal
             });
-            body = await response.json();
+            body = await decodeJsonResponse(response, "invalid_device_authorization_response", "The authorization service returned an invalid device authorization response.");
         }
         catch (cause) {
             popup?.close();
@@ -333,7 +356,7 @@ export class MdbaseConnectInternals {
             popup?.close();
             await this.keyStore.delete(keyHandle);
             if (options.signal?.aborted) {
-                throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause: error });
+                throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.", error);
             }
             throw error;
         }
@@ -366,7 +389,7 @@ export class MdbaseConnectInternals {
             while (Date.now() < authorization.expiresAt) {
                 await abortableDelay(intervalSeconds * 1_000, options.signal);
                 if (options.signal?.aborted) {
-                    throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.");
+                    throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.");
                 }
                 let tokenResponse;
                 try {
@@ -384,11 +407,11 @@ export class MdbaseConnectInternals {
                 }
                 catch (cause) {
                     if (options.signal?.aborted) {
-                        throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause });
+                        throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.", cause);
                     }
                     continue;
                 }
-                const tokenBody = await tokenResponse.json();
+                const tokenBody = await decodeJsonResponse(tokenResponse, "invalid_token_response", "The authorization service returned an invalid token response.");
                 if (!tokenResponse.ok) {
                     const code = oauthErrorCode(tokenBody);
                     if (code === "authorization_pending") {
@@ -402,7 +425,7 @@ export class MdbaseConnectInternals {
                 }
                 const authority = validAuthorityTokenResponse(tokenBody.authority, tokenBody.collection_id);
                 const localEncryption = tokenBody.encryption
-                    && tokenBody.encryption.protocol_version === ENCRYPTED_RELAY_PROTOCOL_VERSION
+                    && tokenBody.encryption.protocol_version === GRANT_ENCRYPTION_PROTOCOL_VERSION
                     && tokenBody.encryption.suite === RELAY_ENCRYPTION_SUITE
                     && tokenBody.encryption.application_agreement_public_key
                         === grantKey.agreementPublicKey;
@@ -437,12 +460,15 @@ export class MdbaseConnectInternals {
             popup?.close();
             await this.keyStore.delete(keyHandle);
             if (options.signal?.aborted) {
-                throw connectError("authorization_cancelled", "Downloaded application authorization was cancelled.", { cause: error });
+                throw authorizationAbort(options.signal, "Downloaded application authorization was cancelled.", error);
             }
             throw error;
         }
     }
-    completeAuthorization(callbackUrl) {
+    completeAuthorization(callbackUrl, options = {}) {
+        return withRequestBudget(options, this.timeouts.requestMs, (budget) => this.completeAuthorizationWithinBudget(callbackUrl, budget.signal));
+    }
+    completeAuthorizationWithinBudget(callbackUrl, signal) {
         const state = new URL(callbackUrl).searchParams.get("state");
         if (!state) {
             return Promise.reject(connectError("invalid_callback", "Authorization callback is missing its state."));
@@ -450,7 +476,7 @@ export class MdbaseConnectInternals {
         const existing = this.completionPromises.get(state);
         if (existing)
             return existing;
-        const completion = this.performAuthorizationCompletion(callbackUrl, state);
+        const completion = this.performAuthorizationCompletion(callbackUrl, state, signal);
         const shared = completion.finally(() => {
             if (this.completionPromises.get(state) === shared)
                 this.completionPromises.delete(state);
@@ -458,7 +484,7 @@ export class MdbaseConnectInternals {
         this.completionPromises.set(state, shared);
         return shared;
     }
-    async performAuthorizationCompletion(callbackUrl, state) {
+    async performAuthorizationCompletion(callbackUrl, state, signal) {
         const callback = new URL(callbackUrl);
         const code = callback.searchParams.get("code");
         const pendingKey = this.pendingKey(state);
@@ -484,9 +510,10 @@ export class MdbaseConnectInternals {
                 client_id: pending.clientId,
                 redirect_uri: pending.redirectUri,
                 code_verifier: pending.verifier
-            })
+            }),
+            signal
         }, "temporarily_unavailable", "Authorization completion is temporarily unavailable.");
-        const body = await response.json();
+        const body = await decodeJsonResponse(response, "invalid_token_response", "The authorization service returned an invalid token response.");
         if (!response.ok)
             throw apiError(body, "token_exchange_failed", "Authorization could not be completed.", response.status);
         if (pending.relayEncryption === "required" && !body.authority && (!body.encryption
@@ -555,78 +582,18 @@ export class MdbaseConnectInternals {
         if (typeof collectionId !== "string") {
             throw connectError("invalid_token_response", "Authorization returned no collection ID.");
         }
-        const scope = parseGrantScope(body.scope);
-        if (!scope) {
-            throw connectError("invalid_token_response", "Authorization returned no valid collection scope.");
-        }
-        if (body.authority && !validAuthorityTokenResponse(body.authority, collectionId)) {
-            throw connectError("invalid_token_response", "Authorization returned an invalid remote authority capability.");
-        }
-        if (body.authority && body.encryption) {
-            throw connectError("invalid_token_response", "Authorization returned conflicting collection transports.");
-        }
-        if (body.file_capability !== null && body.file_capability !== undefined
-            && !validFileCapability(body.file_capability)) {
-            throw connectError("invalid_token_response", "Authorization returned an invalid file capability.");
-        }
-        if (body.encryption) {
-            try {
-                validateGrantEncryption(body.encryption);
-            }
-            catch {
-                throw connectError("invalid_token_response", "Authorization returned an invalid encrypted relay binding.");
-            }
-            this.pinConnectorIdentity(body.encryption.connector_id, body.encryption.connector_agreement_public_key);
-            if (body.encryption.collection_id !== collectionId
-                || typeof body.grant_id !== "string"
-                || body.grant_id.length === 0) {
-                throw connectError("invalid_token_response", "Authorization returned an encrypted relay binding for another grant.");
-            }
-        }
         const previous = parseStored(this.storage.getItem(this.tokenKey(collectionId)));
-        if (previous?.encryption
-            && body.encryption
-            && previous.keyHandle
-            && previous.keyHandle === keyHandle
-            && (previous.grantId !== body.grant_id
-                || previous.encryption.connector_id !== body.encryption.connector_id
-                || previous.encryption.connector_agreement_public_key
-                    !== body.encryption.connector_agreement_public_key
-                || previous.encryption.application_agreement_public_key
-                    !== body.encryption.application_agreement_public_key)) {
-            throw connectError("connector_identity_changed", "The connector identity changed during authorization renewal. Reauthorize before sending collection data.");
-        }
+        const token = storedTokenFromResponse({
+            body,
+            clientId,
+            keyHandle,
+            previous,
+            defaultApplicationOrigin: this.defaultApplicationOrigin(),
+            pinConnectorIdentity: (connectorId, publicKey) => this.pinConnectorIdentity(connectorId, publicKey)
+        });
         if (previous?.keyHandle && previous.keyHandle !== keyHandle) {
             void this.keyStore.delete(previous.keyHandle).catch(() => undefined);
         }
-        const token = {
-            version: 1,
-            accessToken: body.access_token,
-            refreshToken: body.refresh_token,
-            clientId,
-            collectionId,
-            collectionName: body.collection_name ?? `Collection ${collectionId.slice(0, 8)}`,
-            operations: body.operations,
-            scope,
-            expiresAt: Date.now() + body.expires_in * 1_000,
-            refreshExpiresAt: body.refresh_expires_in
-                ? Date.now() + body.refresh_expires_in * 1_000
-                : undefined,
-            grantId: body.grant_id,
-            encryption: body.encryption ?? undefined,
-            fileCapability: body.file_capability ?? undefined,
-            applicationOrigin: body.application_origin ?? this.defaultApplicationOrigin(),
-            keyHandle,
-            savedAt: Date.now(),
-            authority: body.authority ? {
-                operationsUrl: body.authority.operations_url,
-                syncUrl: body.authority.sync_url,
-                filesUrl: body.authority.files_url,
-                replicaId: body.authority.replica_id,
-                accessToken: body.authority.access_token,
-                proofPublicKey: body.authority.proof_public_key
-            } : undefined
-        };
         this.storage.setItem(this.tokenKey(collectionId), JSON.stringify(token));
         this.addConnectionId(collectionId);
         this.invalidatedConnections.delete(collectionId);
@@ -659,12 +626,14 @@ export class MdbaseConnectInternals {
                 : "The application installation identity is unavailable.", { cause });
         }
     }
-    removeToken(collectionId, keyHandle, reason = "authorization_lost") {
+    removeToken(collectionId, keyHandle, reason = "authorization_lost", discardPending = false) {
         this.invalidatedConnections.set(collectionId, reason);
-        if (keyHandle)
+        if (keyHandle && (discardPending || !this.pendingMutationsUseKey(collectionId, keyHandle))) {
             void this.keyStore.delete(keyHandle).catch(() => undefined);
+        }
         this.storage.removeItem(this.tokenKey(collectionId));
-        this.storage.removeItem(this.pendingMutationKey(collectionId));
+        if (discardPending)
+            this.removePendingMutations(collectionId);
         for (const transport of ["web_push", "fcm"]) {
             this.storage.removeItem(this.notificationKey(collectionId, transport));
         }
@@ -681,6 +650,33 @@ export class MdbaseConnectInternals {
     pendingMutationKey(collectionId) {
         return `${this.storagePrefix()}:pending-mutation:${collectionId}`;
     }
+    removePendingMutations(collectionId) {
+        const baseKey = this.pendingMutationKey(collectionId);
+        const keys = [baseKey];
+        for (let index = 0; index < this.storage.length; index += 1) {
+            const key = this.storage.key(index);
+            if (key?.startsWith(`${baseKey}:`))
+                keys.push(key);
+        }
+        for (const key of keys) {
+            const pending = parseStored(this.storage.getItem(key));
+            if (pending?.keyHandle)
+                void this.keyStore.delete(pending.keyHandle).catch(() => undefined);
+            this.storage.removeItem(key);
+        }
+    }
+    pendingMutationsUseKey(collectionId, keyHandle) {
+        const baseKey = this.pendingMutationKey(collectionId);
+        for (let index = 0; index < this.storage.length; index += 1) {
+            const key = this.storage.key(index);
+            if (key !== baseKey && !key?.startsWith(`${baseKey}:`))
+                continue;
+            const pending = parseStored(this.storage.getItem(key));
+            if (pending?.keyHandle === keyHandle)
+                return true;
+        }
+        return false;
+    }
     notificationKey(collectionId, transport = "web_push") {
         return `${this.storagePrefix()}:notifications:${collectionId}:${transport}`;
     }
@@ -718,3 +714,8 @@ export class MdbaseConnectInternals {
             listener(connections);
     }
 }
+function authorizationAbort(signal, message, cause) {
+    if (signal.reason instanceof MdbaseConnectError)
+        return signal.reason;
+    return connectError("authorization_cancelled", message, { cause });
+}

package/dist/connection-file-transport.d.ts

@@ -6,8 +6,8 @@ export interface ConnectionFileTransportOptions {
     keyStore: GrantKeyStore;
     serverUrl: string;
     loopbackUrl: string;
-    authorizedToken(): Promise<StoredToken | null>;
-    refreshAuthorization(): Promise<StoredToken>;
+    authorizedToken(signal?: AbortSignal): Promise<StoredToken | null>;
+    refreshAuthorization(signal?: AbortSignal): Promise<StoredToken>;
     shouldAttemptDirect(token: StoredToken): Promise<boolean>;
     onDirectAvailable(): void;
     onDirectUnavailable(): void;

package/dist/connection-file-transport.js

@@ -13,7 +13,7 @@ export class ConnectionFileTransport {
         this.local = new LocalFileTransport(options);
     }
     async control(method, path = "", input, signal) {
-        const token = await this.requireFileToken();
+        const token = await this.requireFileToken(signal);
         if (!token.authority) {
             return this.local.control(token, method, path, input, signal);
         }
@@ -26,14 +26,14 @@ export class ConnectionFileTransport {
         return this.local.downloadChunk(session, chunkIndex, signal);
     }
     async downloadHostedPart(session, partIndex, expectedLength, signal) {
-        const token = await this.requireFileToken();
+        const token = await this.requireFileToken(signal);
         if (!token.authority) {
             throw connectError("not_remote_authority", "Hosted file delivery requires a remote authority endpoint.");
         }
         return performHostedFilePartRequest(token, `downloads/${encodeURIComponent(session.transfer_id)}/parts/${partIndex}`, expectedLength, signal, this.options.refreshAuthorization, this.options.authorityProofHeaders);
     }
-    async requireFileToken() {
-        const token = await this.options.authorizedToken();
+    async requireFileToken(signal) {
+        const token = await this.options.authorizedToken(signal);
         if (!token?.fileCapability) {
             throw connectError("not_authorized", "This connection has no file capability.");
         }

package/dist/connection-notifications.d.ts

@@ -1,17 +1,20 @@
 import type { Application } from "./internal-types.js";
 import type { StoredToken } from "./internal-types.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
 import type { MdbaseNativeNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNotificationRegistrationOptions } from "./notifications.js";
 export interface ConnectionNotificationContext {
     serverUrl: string;
     storage: Storage;
-    authorizedToken(): Promise<StoredToken | null>;
-    register(): Promise<Application>;
+    authorizedToken(signal?: AbortSignal): Promise<StoredToken | null>;
+    register(signal?: AbortSignal): Promise<Application>;
     notificationKey(transport?: "web_push" | "fcm"): string;
+    requestTimeoutMs: number | null;
 }
 export declare class ConnectionNotifications {
     private readonly context;
     constructor(context: ConnectionNotificationContext);
     registerNotifications(options: MdbaseNotificationRegistrationOptions): Promise<MdbaseNotificationRegistration>;
+    private registerNotificationsWithinBudget;
     /**
      * Register an iOS or Android installation for Connect-managed FCM.
      *
@@ -19,7 +22,10 @@ export declare class ConnectionNotifications {
      * same installation whenever Firebase refreshes its token.
      */
     registerNativeNotifications(options: MdbaseNativeNotificationRegistrationOptions): Promise<MdbaseNativeNotificationRegistration>;
-    unregisterNativeNotifications(): Promise<void>;
-    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration): Promise<void>;
+    private registerNativeNotificationsWithinBudget;
+    unregisterNativeNotifications(options?: ConnectRequestOptions): Promise<void>;
+    private unregisterNativeNotificationsWithinBudget;
+    unregisterNotifications(serviceWorker?: ServiceWorkerRegistration, options?: ConnectRequestOptions): Promise<void>;
+    private unregisterNotificationsWithinBudget;
     private deleteNotificationChannel;
 }