@warp-drive/core 5.6.0-alpha.18 → 5.6.0-alpha.5

package/declarations/store/-private/cache-handler/handler.d.ts

@@ -1,62 +0,0 @@
-import type { CacheHandler as CacheHandlerType } from "../../../request.js";
-import type { ImmutableRequestInfo, RequestContext } from "../../../types/request.js";
-import type { ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
-import type { RequestSignature } from "../../../types/symbols.js";
-import type { Store } from "../store-service.js";
-export type LooseStoreRequestInfo<
-	RT = unknown,
-	T = unknown
-> = Omit<ImmutableRequestInfo<RT, T>, "records" | "headers" | typeof RequestSignature> & {
-	records?: ResourceIdentifierObject[];
-	headers?: Headers;
-};
-export type StoreRequestInput<
-	RT = unknown,
-	T = unknown
-> = ImmutableRequestInfo<RT, T> | LooseStoreRequestInfo<RT, T>;
-export interface StoreRequestContext extends RequestContext {
-	request: ImmutableRequestInfo & {
-		store: Store;
-	};
-}
-/**
-* A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
-*
-* This handler will only run when a request has supplied a `store` instance. Requests
-* issued by the store via `store.request()` will automatically have the `store` instance
-* attached to the request.
-*
-* ```ts
-* requestManager.request({
-*   store: store,
-*   url: '/api/posts',
-*   method: 'GET'
-* });
-* ```
-*
-* When this handler elects to handle a request, it will return the raw `StructuredDocument`
-* unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
-* return a `Document` instance that will automatically update the UI when the cache is updated
-* in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
-*
-* When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
-* means that if desired you can issue requests that utilize the cache without needing to also
-* utilize Record instances if desired.
-*
-* Said differently, you could elect to issue all requests via a RequestManager, without ever using
-* the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
-* necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
-* approach of WarpDrive allows for this flexibility.
-*
-* ```ts
-* import { EnableHydration } from '@warp-drive/core/types/request';
-*
-* requestManager.request({
-*   store: store,
-*   url: '/api/posts',
-*   method: 'GET',
-*   [EnableHydration]: true
-* });
-*
-*/
-export declare const CacheHandler: CacheHandlerType;

package/declarations/store/-private/cache-handler/types.d.ts

@@ -1,98 +0,0 @@
-import type { StableDocumentIdentifier } from "../../../types/identifier.js";
-import type { ImmutableRequestInfo, ResponseInfo } from "../../../types/request.js";
-import type { Store } from "../store-service.js";
-/**
-* A service which an application may provide to the store via
-* the store's `lifetimes` property to configure the behavior
-* of the CacheHandler.
-*
-* The default behavior for request lifetimes is to never expire
-* unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
-*
-* Implementing this service allows you to programatically define
-* when a request should be considered expired.
-*
-* @class (Interface) CachePolicy
-* @public
-*/
-export interface CachePolicy {
-	/**
-	* Invoked to determine if the request may be fulfilled from cache
-	* if possible.
-	*
-	* Note, this is only invoked if the request has a cache-key.
-	*
-	* If no cache entry is found or the entry is hard expired,
-	* the request will be fulfilled from the configured request handlers
-	* and the cache will be updated before returning the response.
-	*
-	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	* @return {Boolean} true if the request is considered hard expired
-	*/
-	isHardExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
-	/**
-	* Invoked if `isHardExpired` is false to determine if the request
-	* should be update behind the scenes if cache data is already available.
-	*
-	* Note, this is only invoked if the request has a cache-key.
-	*
-	* If true, the request will be fulfilled from cache while a backgrounded
-	* request is made to update the cache via the configured request handlers.
-	*
-	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	* @return {Boolean} true if the request is considered soft expired
-	*/
-	isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
-	/**
-	* Invoked when a request will be sent to the configured request handlers.
-	* This is invoked for both foreground and background requests.
-	*
-	* Note, this is invoked regardless of whether the request has a cache-key.
-	*
-	* @public
-	* @param {ImmutableRequestInfo} request
-	* @param {StableDocumentIdentifier | null} identifier
-	* @param {Store} store
-	* @return {void}
-	*/
-	willRequest?(request: ImmutableRequestInfo, identifier: StableDocumentIdentifier | null, store: Store): void;
-	/**
-	* Invoked when a request has been fulfilled from the configured request handlers.
-	* This is invoked for both foreground and background requests once the cache has
-	* been updated.
-	*
-	* Note, this is invoked regardless of whether the request has a cache-key.
-	*
-	* It is best practice to notify the store of any requests marked as invalidated
-	* so that request subscriptions can reload when needed.
-	*
-	* ```ts
-	* store.notifications.notify(identifier, 'invalidated');
-	* ```
-	*
-	* This allows anything subscribed to the request to be notified of the change
-	*
-	* e.g.
-	*
-	* ```ts
-	* store.notifications.subscribe(identifier, (_, type) => {
-	*   if (type === 'invalidated') {
-	*     // do update
-	*   }
-	* });
-	* ```
-	*
-	*
-	* @public
-	* @param {ImmutableRequestInfo} request
-	* @param {ImmutableResponse} response
-	* @param {StableDocumentIdentifier | null} identifier
-	* @param {Store} store
-	* @return {void}
-	*/
-	didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
-}

package/declarations/store/-private/cache-handler/utils.d.ts

@@ -1,32 +0,0 @@
-import type { StableDocumentIdentifier } from "../../../types/identifier.js";
-import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "../../../types/request.js";
-import type { ResourceDataDocument, ResourceErrorDocument } from "../../../types/spec/document.js";
-import type { ApiError } from "../../../types/spec/error.js";
-import type { Store } from "../store-service.js";
-export declare const MUTATION_OPS: Set<string>;
-export declare function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: boolean, identifier: StableDocumentIdentifier | null): boolean;
-export declare function calcShouldBackgroundFetch(store: Store, request: ImmutableRequestInfo, willFetch: boolean, identifier: StableDocumentIdentifier | null): boolean;
-export declare function isMutation(request: Partial<ImmutableRequestInfo>): request is ImmutableUpdateRequestOptions | ImmutableCreateRequestOptions | ImmutableDeleteRequestOptions;
-export declare function isCacheAffecting<T>(document: StructuredDataDocument<T>): boolean;
-export declare function isAggregateError(error: Error & {
-	errors?: ApiError[];
-}): error is AggregateError & {
-	errors: ApiError[];
-};
-export type RobustError = Error & {
-	error: string | object;
-	errors?: ApiError[];
-	content?: unknown;
-};
-// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
-export declare function cloneError(error: RobustError): RobustError;
-export declare function isErrorDocument(document: ResourceDataDocument | ResourceErrorDocument): document is ResourceErrorDocument;
-export declare function getPriority(identifier: StableDocumentIdentifier | null, deduped: Map<StableDocumentIdentifier, {
-	priority: {
-		blocking: boolean;
-	};
-}>, priority: {
-	blocking: boolean;
-}): {
-	blocking: boolean;
-};

package/declarations/store/-private/caches/cache-utils.d.ts

@@ -1,12 +0,0 @@
-import type { Cache } from "../../../types/cache.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
-/*
-* Returns the Cache instance associated with a given
-* Model or Identifier
-*/
-export declare const CacheForIdentifierCache: Map<unknown, Cache>;
-export declare function setCacheFor(identifier: StableRecordIdentifier | OpaqueRecordInstance, cache: Cache): void;
-export declare function removeRecordDataFor(identifier: StableRecordIdentifier | OpaqueRecordInstance): void;
-export declare function peekCache(instance: StableRecordIdentifier): Cache | null;
-export declare function peekCache(instance: OpaqueRecordInstance): Cache;

package/declarations/store/-private/caches/identifier-cache.d.ts

@@ -1,304 +0,0 @@
-import { type Identifier, type RecordIdentifier, type StableDocumentIdentifier, type StableExistingRecordIdentifier, type StableRecordIdentifier } from "../../../types/identifier.js";
-import type { ImmutableRequestInfo } from "../../../types/request.js";
-import type { ExistingResourceIdentifierObject, ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
-import type { ForgetMethod, GenerationMethod, KeyInfo, KeyInfoMethod, ResetMethod, UpdateMethod } from "../../-types/q/identifier.js";
-type TypeFromIdentifier<T> = T extends {
-	type: infer U;
-} ? U : string;
-type NarrowIdentifierIfPossible<T> = T extends ExistingResourceIdentifierObject ? StableExistingRecordIdentifier<TypeFromIdentifier<T>> : StableRecordIdentifier;
-export declare function isStableIdentifier(identifier: unknown): identifier is StableRecordIdentifier;
-export declare function isDocumentIdentifier(identifier: unknown): identifier is StableDocumentIdentifier;
-interface KeyOptions {
-	lid: IdentifierMap;
-	id: IdentifierMap;
-}
-type TypeMap = {
-	[key: string]: KeyOptions;
-};
-// type IdentifierTypeLookup = { all: Set<StableRecordIdentifier>; id: Map<string, StableRecordIdentifier> };
-// type IdentifiersByType = Map<string, IdentifierTypeLookup>;
-type IdentifierMap = Map<string, StableRecordIdentifier>;
-type StableCache = {
-	resources: IdentifierMap;
-	documents: Map<string, StableDocumentIdentifier>;
-	resourcesByType: TypeMap;
-	polymorphicLidBackMap: Map<string, string[]>;
-};
-export type MergeMethod = (targetIdentifier: StableRecordIdentifier, matchedIdentifier: StableRecordIdentifier, resourceData: unknown) => StableRecordIdentifier;
-/**
-Configures how unique identifier lid strings are generated by @ember-data/store.
-
-This configuration MUST occur prior to the store instance being created.
-
-Takes a method which can expect to receive various data as its first argument
-and the name of a bucket as its second argument.
-
-Currently there are two buckets, 'record' and 'document'.
-
-### Resource (`Record`) Identity
-
-If the bucket is `record` the method must return a unique (to at-least
-the given bucket) string identifier for the given data as a string to be
-used as the `lid` of an `Identifier` token.
-
-This method will only be called by either `getOrCreateRecordIdentifier` or
-`createIdentifierForNewRecord` when an identifier for the supplied data
-is not already known via `lid` or `type + id` combo and one needs to be
-generated or retrieved from a proprietary cache.
-
-`data` will be the same data argument provided to `getOrCreateRecordIdentifier`
-and in the `createIdentifierForNewRecord` case will be an object with
-only `type` as a key.
-
-```ts
-import { setIdentifierGenerationMethod } from '@warp-drive/core';
-
-export function initialize(applicationInstance) {
-// note how `count` here is now scoped to the application instance
-// for our generation method by being inside the closure provided
-// by the initialize function
-let count = 0;
-
-setIdentifierGenerationMethod((resource, bucket) => {
-return resource.lid || `my-key-${count++}`;
-});
-}
-
-export default {
-name: 'configure-ember-data-identifiers',
-initialize
-};
-```
-
-### Document Identity
-
-If the bucket is `document` the method will receive the associated
-immutable `request` passed to `store.request` as its first argument
-and should return a unique string for the given request if the document
-should be cached, and `null` if it should not be cached.
-
-Note, the request result will still be passed to the cache via `Cache.put`,
-but caches should take this as a signal that the document should not itself
-be cached, while its contents may still be used to update other cache state.
-
-The presence of `cacheOptions.key` on the request will take precedence
-for the document cache key, and this method will not be called if it is
-present.
-
-The default method implementation for this bucket is to return `null`
-for all requests whose method is not `GET`, and to return the `url` for
-those where it is.
-
-This means that queries via `POST` MUST provide `cacheOptions.key` or
-implement this hook.
-
-⚠️ Caution: Requests that do not have a `method` assigned are assumed to be `GET`
-
-@public
-*/
-export declare function setIdentifierGenerationMethod(method: GenerationMethod | null): void;
-/**
-Configure a callback for when the identifier cache encounters new resource
-data for an existing resource.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setIdentifierUpdateMethod } from '@warp-drive/core';
-```
-
-Takes a method which can expect to receive an existing `Identifier` alongside
-some new data to consider as a second argument. This is an opportunity
-for secondary lookup tables and caches associated with the identifier
-to be amended.
-
-This method is called everytime `updateRecordIdentifier` is called and
-with the same arguments. It provides the opportunity to update secondary
-lookup tables for existing identifiers.
-
-It will always be called after an identifier created with `createIdentifierForNewRecord`
-has been committed, or after an update to the `record` a `RecordIdentifier`
-is assigned to has been committed. Committed here meaning that the server
-has acknowledged the update (for instance after a call to `.save()`)
-
-If `id` has not previously existed, it will be assigned to the `Identifier`
-prior to this `UpdateMethod` being called; however, calls to the parent method
-`updateRecordIdentifier` that attempt to change the `id` or calling update
-without providing an `id` when one is missing will throw an error.
-
-@public
-*/
-export declare function setIdentifierUpdateMethod(method: UpdateMethod | null): void;
-/**
-Configure a callback for when the identifier cache is going to release an identifier.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setIdentifierForgetMethod } from '@warp-drive/core';
-```
-
-Takes method which can expect to receive an existing `Identifier` that should be eliminated
-from any secondary lookup tables or caches that the user has populated for it.
-
-@public
-*/
-export declare function setIdentifierForgetMethod(method: ForgetMethod | null): void;
-/**
-Configure a callback for when the identifier cache is being torn down.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setIdentifierResetMethod } from '@warp-drive/core';
-```
-
-Takes a method which can expect to be called when the parent application is destroyed.
-
-If you have properly used a WeakMap to encapsulate the state of your customization
-to the application instance, you may not need to implement the `resetMethod`.
-
-@public
-*/
-export declare function setIdentifierResetMethod(method: ResetMethod | null): void;
-/**
-Configure a callback for when the identifier cache is generating a new
-StableRecordIdentifier for a resource.
-
-This method controls the `type` and `id` that will be assigned to the
-`StableRecordIdentifier` that is created.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setKeyInfoForResource } from '@warp-drive/core';
-```
-
-@public
-*/
-export declare function setKeyInfoForResource(method: KeyInfoMethod | null): void;
-/**
-* Each instance of {@link Store} receives a unique instance of a IdentifierCache.
-*
-* This cache is responsible for assigning or retrieving the unique identify
-* for arbitrary resource data encountered by the store. Data representing
-* a unique resource or record should always be represented by the same
-* identifier.
-*
-* It can be configured by consuming applications.
-*
-* @hideconstructor
-* @public
-*/
-export declare class IdentifierCache {
-	/** @internal */
-	_cache: StableCache;
-	private _generate;
-	private _update;
-	private _forget;
-	private _reset;
-	private _merge;
-	private _keyInfoForResource;
-	private _id;
-	constructor();
-	/**
-	* Internal hook to allow management of merge conflicts with identifiers.
-	*
-	* we allow late binding of this private internal merge so that
-	* the cache can insert itself here to handle elimination of duplicates
-	*
-	* @private
-	*/
-	__configureMerge(method: MergeMethod | null): void;
-	/** @internal */
-	upgradeIdentifier(resource: {
-		type: string;
-		id: string | null;
-		lid?: string;
-	}): StableRecordIdentifier;
-	/**
-	* @private
-	*/
-	private _getRecordIdentifier;
-	private _getRecordIdentifier;
-	private _getRecordIdentifier;
-	/**
-	* allows us to peek without generating when needed
-	* useful for the "create" case when we need to see if
-	* we are accidentally overwritting something
-	*
-	* @private
-	*/
-	peekRecordIdentifier(resource: ResourceIdentifierObject | Identifier): StableRecordIdentifier | undefined;
-	/**
-	Returns the DocumentIdentifier for the given Request, creates one if it does not yet exist.
-	Returns `null` if the request does not have a `cacheKey` or `url`.
-	
-	@public
-	*/
-	getOrCreateDocumentIdentifier(request: ImmutableRequestInfo): StableDocumentIdentifier | null;
-	/**
-	Returns the Identifier for the given Resource, creates one if it does not yet exist.
-	
-	Specifically this means that we:
-	
-	- validate the `id` `type` and `lid` combo against known identifiers
-	- return an object with an `lid` that is stable (repeated calls with the same
-	`id` + `type` or `lid` will return the same `lid` value)
-	- this referential stability of the object itself is guaranteed
-	
-	@public
-	*/
-	getOrCreateRecordIdentifier<T>(resource: T): NarrowIdentifierIfPossible<T>;
-	/**
-	Returns a new Identifier for the supplied data. Call this method to generate
-	an identifier when a new resource is being created local to the client and
-	potentially does not have an `id`.
-	
-	Delegates generation to the user supplied `GenerateMethod` if one has been provided
-	with the signature `generateMethod({ type }, 'record')`.
-	
-	@public
-	*/
-	createIdentifierForNewRecord(data: {
-		type: string;
-		id?: string | null;
-	}): StableRecordIdentifier;
-	/**
-	Provides the opportunity to update secondary lookup tables for existing identifiers
-	Called after an identifier created with `createIdentifierForNewRecord` has been
-	committed.
-	
-	Assigned `id` to an `Identifier` if `id` has not previously existed; however,
-	attempting to change the `id` or calling update without providing an `id` when
-	one is missing will throw an error.
-	
-	- sets `id` (if `id` was previously `null`)
-	- `lid` and `type` MUST NOT be altered post creation
-	
-	If a merge occurs, it is possible the returned identifier does not match the originally
-	provided identifier. In this case the abandoned identifier will go through the usual
-	`forgetRecordIdentifier` codepaths.
-	
-	@public
-	*/
-	updateRecordIdentifier(identifierObject: RecordIdentifier, data: unknown): StableRecordIdentifier;
-	/**
-	* @private
-	*/
-	_mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: StableRecordIdentifier, existingIdentifier: StableRecordIdentifier, data: unknown): StableRecordIdentifier;
-	/**
-	Provides the opportunity to eliminate an identifier from secondary lookup tables
-	as well as eliminates it from ember-data's own lookup tables and book keeping.
-	
-	Useful when a record has been deleted and the deletion has been persisted and
-	we do not care about the record anymore. Especially useful when an `id` of a
-	deleted record might be reused later for a new record.
-	
-	@public
-	*/
-	forgetRecordIdentifier(identifierObject: RecordIdentifier): void;
-	/** @internal */
-	destroy(): void;
-}
-export {};

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -1,65 +0,0 @@
-import { ReactiveDocument } from "../../../reactive/-private/document.js";
-import type { Cache } from "../../../types/cache.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
-import type { Value } from "../../../types/json/raw.js";
-import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
-import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
-import RecordReference from "../legacy-model-support/record-reference.js";
-import { CacheCapabilitiesManager } from "../managers/cache-capabilities-manager.js";
-import type { CacheManager } from "../managers/cache-manager.js";
-import type { CreateRecordProperties, Store } from "../store-service.js";
-export declare function peekRecordIdentifier(record: OpaqueRecordInstance): StableRecordIdentifier | undefined;
-/**
-Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)
-assigned to the given record instance.
-
-```js
-import { recordIdentifierFor } from "@ember-data/store";
-// ... gain access to a record, for instance with peekRecord or findRecord
-const record = store.peekRecord("user", "1");
-// get the identifier for the record (see docs for StableRecordIdentifier)
-const identifier = recordIdentifierFor(record);
-// access the identifier's properties.
-const { id, type, lid } = identifier;
-```
-
-@public
-@param {Object} record a record instance previously obstained from the store.
-@return {StableRecordIdentifier}
-*/
-export declare function recordIdentifierFor<T extends TypedRecordInstance>(record: T): StableRecordIdentifier<TypeFromInstance<T>>;
-export declare function recordIdentifierFor(record: OpaqueRecordInstance): StableRecordIdentifier;
-export declare function setRecordIdentifier(record: OpaqueRecordInstance, identifier: StableRecordIdentifier): void;
-export declare const StoreMap: Map<unknown, Store>;
-/**
-* We may eventually make this public, but its likely better for this to be killed off
-* @internal
-*/
-export declare function storeFor(record: OpaqueRecordInstance): Store | undefined;
-type Caches = {
-	record: Map<StableRecordIdentifier, OpaqueRecordInstance>;
-	reference: WeakMap<StableRecordIdentifier, RecordReference>;
-	document: Map<StableDocumentIdentifier, ReactiveDocument<OpaqueRecordInstance | OpaqueRecordInstance[] | null | undefined>>;
-};
-export declare class InstanceCache {
-	store: Store;
-	cache: Cache;
-	_storeWrapper: CacheCapabilitiesManager;
-	__cacheManager: CacheManager;
-	__instances: Caches;
-	constructor(store: Store);
-	peek(identifier: StableRecordIdentifier): Cache | OpaqueRecordInstance | undefined;
-	getDocument<T>(identifier: StableDocumentIdentifier): ReactiveDocument<T>;
-	getRecord(identifier: StableRecordIdentifier, properties?: CreateRecordProperties): OpaqueRecordInstance;
-	getReference(identifier: StableRecordIdentifier): RecordReference;
-	recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted?: boolean): boolean;
-	disconnect(identifier: StableRecordIdentifier): void;
-	unloadRecord(identifier: StableRecordIdentifier): void;
-	clear(type?: string): void;
-	// TODO this should move into something coordinating operations
-	setRecordId(identifier: StableRecordIdentifier, id: string): void;
-}
-export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: StableRecordIdentifier): boolean;
-export declare function preloadData(store: Store, identifier: StableRecordIdentifier, preload: Record<string, Value>): void;
-export declare function _clearCaches(): void;
-export {};

package/declarations/store/-private/caches/resource-utils.d.ts

@@ -1,9 +0,0 @@
-export declare function hasLid(resource: unknown): resource is {
-	lid: string;
-};
-export declare function hasId(resource: unknown): resource is {
-	id: string;
-};
-export declare function hasType(resource: unknown): resource is {
-	type: string;
-};

package/declarations/store/-private/debug/utils.d.ts

@@ -1,6 +0,0 @@
-export declare function logGroup(scope: "cache", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function logGroup(scope: "reactive-ui", prefix: string, type: string, lid: string, bucket: string, key: ""): void;
-export declare function logGroup(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function log(scope: "cache", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function log(scope: "reactive-ui", prefix: string, type: string, lid: string, bucket: string, key: ""): void;
-export declare function log(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;