@fluidframework/counter 2.0.0-internal.7.2.2 → 2.0.0-internal.7.3.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @fluidframework/counter
 
+## 2.0.0-internal.7.3.0
+
+Dependency updates only.
+
 ## 2.0.0-internal.7.2.0
 
 Dependency updates only.

package/README.md

@@ -182,8 +182,7 @@ API documentation for **@fluidframework/counter** is available at <https://fluid
 
 This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
 
-Use of these trademarks or logos must follow Microsoft's [Trademark & Brand
-Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+Use of these trademarks or logos must follow Microsoft's [Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
 
 Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
 

package/api-extractor.json

@@ -1,13 +1,7 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
 	"extends": "@fluidframework/build-common/api-extractor-base.json",
-
-	// TODO: Fix violations and remove these rule overrides
-	"messages": {
-		"extractorMessageReporting": {
-			"ae-forgotten-export": {
-				"logLevel": "none"
-			}
-		}
+	"dtsRollup": {
+		"enabled": true
 	}
 }

package/api-report/counter.api.md

@@ -30,18 +30,15 @@ export interface ISharedCounterEvents extends ISharedObjectEvents {
 // @public
 export class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {
     constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
-    // @internal (undocumented)
+    // (undocumented)
     protected applyStashedOp(op: unknown): void;
     static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter;
     static getFactory(): IChannelFactory;
     increment(incrementAmount: number): void;
-    // @internal (undocumented)
+    // (undocumented)
     protected loadCore(storage: IChannelStorageService): Promise<void>;
-    // @internal
     protected onDisconnect(): void;
-    // @internal
     protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
-    // @internal
     protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
     get value(): number;
 }

package/dist/counter-alpha.d.ts

@@ -0,0 +1,153 @@
+/**
+ * This library contains the {@link ISharedCounter | SharedCounter} distributed data structure.
+ * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.
+ *
+ * @packageDocumentation
+ */
+
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObject } from '@fluidframework/shared-object-base';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+
+/**
+ * A shared object that holds a number that can be incremented or decremented.
+ *
+ * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.
+ *
+ * @example Creating a `SharedCounter`
+ *
+ * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}
+ * with a runtime and string ID:
+ *
+ * ```typescript
+ * const factory = SharedCounter.getFactory();
+ * const counter = factory.create(this.runtime, id) as SharedCounter;
+ * ```
+ *
+ * The initial value of a new `SharedCounter` is 0.
+ * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before
+ * attaching the Container, or before inserting it into an existing shared object.
+ *
+ * @example Using the `SharedCounter`
+ *
+ * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or
+ * negative number:
+ *
+ * ```typescript
+ * counter.increment(10); // add 10 to the counter value
+ * counter.increment(-5); // subtract 5 from the counter value
+ * ```
+ *
+ * To observe changes to the value (including those from remote clients), register for the
+ * {@link ISharedCounterEvents | incremented} event:
+ *
+ * ```typescript
+ * counter.on("incremented", (incrementAmount, newValue) => {
+ *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare interface ISharedCounter extends ISharedObject<ISharedCounterEvents> {
+    /**
+     * The counter value.
+     *
+     * @remarks Must be a whole number.
+     */
+    value: number;
+    /**
+     * Increments or decrements the value.
+     * Must only increment or decrement by a whole number value.
+     *
+     * @param incrementAmount - A whole number to increment or decrement by.
+     */
+    increment(incrementAmount: number): void;
+}
+
+/**
+ * Events sent by {@link SharedCounter}.
+ *
+ * @public
+ */
+export declare interface ISharedCounterEvents extends ISharedObjectEvents {
+    /**
+     * This event is raised when the counter is incremented or decremented.
+     *
+     * @param event - The event name.
+     * @param listener - An event listener.
+     *
+     * @eventProperty
+     */
+    (event: "incremented", listener: (incrementAmount: number, newValue: number) => void): any;
+}
+
+/**
+ * {@inheritDoc ISharedCounter}
+ *
+ * @public
+ */
+export declare class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {
+    /**
+     * Create a new {@link SharedCounter}.
+     *
+     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.
+     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.
+     *
+     * @returns newly create shared counter (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter;
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Get a factory for {@link SharedCounter} to register with the data store.
+     *
+     * @returns a factory that creates and load SharedCounter
+     */
+    static getFactory(): IChannelFactory;
+    private _value;
+    /**
+     * {@inheritDoc ISharedCounter.value}
+     */
+    get value(): number;
+    /**
+     * {@inheritDoc ISharedCounter.increment}
+     */
+    increment(incrementAmount: number): void;
+    private incrementCore;
+    /**
+     * Create a summary for the counter.
+     *
+     * @returns The summary of the current state of the counter.
+     */
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * Called when the object has disconnected from the delta stream.
+     */
+    protected onDisconnect(): void;
+    /**
+     * Process a counter operation (op).
+     *
+     * @param message - The message to prepare.
+     * @param local - Whether or not the message was sent by the local client.
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be `undefined`.
+     */
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * {@inheritdoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    protected applyStashedOp(op: unknown): void;
+}
+
+export { }

package/dist/counter-beta.d.ts

@@ -0,0 +1,153 @@
+/**
+ * This library contains the {@link ISharedCounter | SharedCounter} distributed data structure.
+ * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.
+ *
+ * @packageDocumentation
+ */
+
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObject } from '@fluidframework/shared-object-base';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+
+/**
+ * A shared object that holds a number that can be incremented or decremented.
+ *
+ * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.
+ *
+ * @example Creating a `SharedCounter`
+ *
+ * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}
+ * with a runtime and string ID:
+ *
+ * ```typescript
+ * const factory = SharedCounter.getFactory();
+ * const counter = factory.create(this.runtime, id) as SharedCounter;
+ * ```
+ *
+ * The initial value of a new `SharedCounter` is 0.
+ * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before
+ * attaching the Container, or before inserting it into an existing shared object.
+ *
+ * @example Using the `SharedCounter`
+ *
+ * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or
+ * negative number:
+ *
+ * ```typescript
+ * counter.increment(10); // add 10 to the counter value
+ * counter.increment(-5); // subtract 5 from the counter value
+ * ```
+ *
+ * To observe changes to the value (including those from remote clients), register for the
+ * {@link ISharedCounterEvents | incremented} event:
+ *
+ * ```typescript
+ * counter.on("incremented", (incrementAmount, newValue) => {
+ *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare interface ISharedCounter extends ISharedObject<ISharedCounterEvents> {
+    /**
+     * The counter value.
+     *
+     * @remarks Must be a whole number.
+     */
+    value: number;
+    /**
+     * Increments or decrements the value.
+     * Must only increment or decrement by a whole number value.
+     *
+     * @param incrementAmount - A whole number to increment or decrement by.
+     */
+    increment(incrementAmount: number): void;
+}
+
+/**
+ * Events sent by {@link SharedCounter}.
+ *
+ * @public
+ */
+export declare interface ISharedCounterEvents extends ISharedObjectEvents {
+    /**
+     * This event is raised when the counter is incremented or decremented.
+     *
+     * @param event - The event name.
+     * @param listener - An event listener.
+     *
+     * @eventProperty
+     */
+    (event: "incremented", listener: (incrementAmount: number, newValue: number) => void): any;
+}
+
+/**
+ * {@inheritDoc ISharedCounter}
+ *
+ * @public
+ */
+export declare class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {
+    /**
+     * Create a new {@link SharedCounter}.
+     *
+     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.
+     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.
+     *
+     * @returns newly create shared counter (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter;
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Get a factory for {@link SharedCounter} to register with the data store.
+     *
+     * @returns a factory that creates and load SharedCounter
+     */
+    static getFactory(): IChannelFactory;
+    private _value;
+    /**
+     * {@inheritDoc ISharedCounter.value}
+     */
+    get value(): number;
+    /**
+     * {@inheritDoc ISharedCounter.increment}
+     */
+    increment(incrementAmount: number): void;
+    private incrementCore;
+    /**
+     * Create a summary for the counter.
+     *
+     * @returns The summary of the current state of the counter.
+     */
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * Called when the object has disconnected from the delta stream.
+     */
+    protected onDisconnect(): void;
+    /**
+     * Process a counter operation (op).
+     *
+     * @param message - The message to prepare.
+     * @param local - Whether or not the message was sent by the local client.
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be `undefined`.
+     */
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * {@inheritdoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    protected applyStashedOp(op: unknown): void;
+}
+
+export { }

package/dist/counter-public.d.ts

@@ -0,0 +1,153 @@
+/**
+ * This library contains the {@link ISharedCounter | SharedCounter} distributed data structure.
+ * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.
+ *
+ * @packageDocumentation
+ */
+
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObject } from '@fluidframework/shared-object-base';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+
+/**
+ * A shared object that holds a number that can be incremented or decremented.
+ *
+ * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.
+ *
+ * @example Creating a `SharedCounter`
+ *
+ * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}
+ * with a runtime and string ID:
+ *
+ * ```typescript
+ * const factory = SharedCounter.getFactory();
+ * const counter = factory.create(this.runtime, id) as SharedCounter;
+ * ```
+ *
+ * The initial value of a new `SharedCounter` is 0.
+ * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before
+ * attaching the Container, or before inserting it into an existing shared object.
+ *
+ * @example Using the `SharedCounter`
+ *
+ * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or
+ * negative number:
+ *
+ * ```typescript
+ * counter.increment(10); // add 10 to the counter value
+ * counter.increment(-5); // subtract 5 from the counter value
+ * ```
+ *
+ * To observe changes to the value (including those from remote clients), register for the
+ * {@link ISharedCounterEvents | incremented} event:
+ *
+ * ```typescript
+ * counter.on("incremented", (incrementAmount, newValue) => {
+ *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare interface ISharedCounter extends ISharedObject<ISharedCounterEvents> {
+    /**
+     * The counter value.
+     *
+     * @remarks Must be a whole number.
+     */
+    value: number;
+    /**
+     * Increments or decrements the value.
+     * Must only increment or decrement by a whole number value.
+     *
+     * @param incrementAmount - A whole number to increment or decrement by.
+     */
+    increment(incrementAmount: number): void;
+}
+
+/**
+ * Events sent by {@link SharedCounter}.
+ *
+ * @public
+ */
+export declare interface ISharedCounterEvents extends ISharedObjectEvents {
+    /**
+     * This event is raised when the counter is incremented or decremented.
+     *
+     * @param event - The event name.
+     * @param listener - An event listener.
+     *
+     * @eventProperty
+     */
+    (event: "incremented", listener: (incrementAmount: number, newValue: number) => void): any;
+}
+
+/**
+ * {@inheritDoc ISharedCounter}
+ *
+ * @public
+ */
+export declare class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {
+    /**
+     * Create a new {@link SharedCounter}.
+     *
+     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.
+     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.
+     *
+     * @returns newly create shared counter (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter;
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Get a factory for {@link SharedCounter} to register with the data store.
+     *
+     * @returns a factory that creates and load SharedCounter
+     */
+    static getFactory(): IChannelFactory;
+    private _value;
+    /**
+     * {@inheritDoc ISharedCounter.value}
+     */
+    get value(): number;
+    /**
+     * {@inheritDoc ISharedCounter.increment}
+     */
+    increment(incrementAmount: number): void;
+    private incrementCore;
+    /**
+     * Create a summary for the counter.
+     *
+     * @returns The summary of the current state of the counter.
+     */
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * Called when the object has disconnected from the delta stream.
+     */
+    protected onDisconnect(): void;
+    /**
+     * Process a counter operation (op).
+     *
+     * @param message - The message to prepare.
+     * @param local - Whether or not the message was sent by the local client.
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be `undefined`.
+     */
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * {@inheritdoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    protected applyStashedOp(op: unknown): void;
+}
+
+export { }

package/dist/counter-untrimmed.d.ts

@@ -0,0 +1,153 @@
+/**
+ * This library contains the {@link ISharedCounter | SharedCounter} distributed data structure.
+ * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.
+ *
+ * @packageDocumentation
+ */
+
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObject } from '@fluidframework/shared-object-base';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+
+/**
+ * A shared object that holds a number that can be incremented or decremented.
+ *
+ * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.
+ *
+ * @example Creating a `SharedCounter`
+ *
+ * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}
+ * with a runtime and string ID:
+ *
+ * ```typescript
+ * const factory = SharedCounter.getFactory();
+ * const counter = factory.create(this.runtime, id) as SharedCounter;
+ * ```
+ *
+ * The initial value of a new `SharedCounter` is 0.
+ * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before
+ * attaching the Container, or before inserting it into an existing shared object.
+ *
+ * @example Using the `SharedCounter`
+ *
+ * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or
+ * negative number:
+ *
+ * ```typescript
+ * counter.increment(10); // add 10 to the counter value
+ * counter.increment(-5); // subtract 5 from the counter value
+ * ```
+ *
+ * To observe changes to the value (including those from remote clients), register for the
+ * {@link ISharedCounterEvents | incremented} event:
+ *
+ * ```typescript
+ * counter.on("incremented", (incrementAmount, newValue) => {
+ *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare interface ISharedCounter extends ISharedObject<ISharedCounterEvents> {
+    /**
+     * The counter value.
+     *
+     * @remarks Must be a whole number.
+     */
+    value: number;
+    /**
+     * Increments or decrements the value.
+     * Must only increment or decrement by a whole number value.
+     *
+     * @param incrementAmount - A whole number to increment or decrement by.
+     */
+    increment(incrementAmount: number): void;
+}
+
+/**
+ * Events sent by {@link SharedCounter}.
+ *
+ * @public
+ */
+export declare interface ISharedCounterEvents extends ISharedObjectEvents {
+    /**
+     * This event is raised when the counter is incremented or decremented.
+     *
+     * @param event - The event name.
+     * @param listener - An event listener.
+     *
+     * @eventProperty
+     */
+    (event: "incremented", listener: (incrementAmount: number, newValue: number) => void): any;
+}
+
+/**
+ * {@inheritDoc ISharedCounter}
+ *
+ * @public
+ */
+export declare class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {
+    /**
+     * Create a new {@link SharedCounter}.
+     *
+     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.
+     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.
+     *
+     * @returns newly create shared counter (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter;
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Get a factory for {@link SharedCounter} to register with the data store.
+     *
+     * @returns a factory that creates and load SharedCounter
+     */
+    static getFactory(): IChannelFactory;
+    private _value;
+    /**
+     * {@inheritDoc ISharedCounter.value}
+     */
+    get value(): number;
+    /**
+     * {@inheritDoc ISharedCounter.increment}
+     */
+    increment(incrementAmount: number): void;
+    private incrementCore;
+    /**
+     * Create a summary for the counter.
+     *
+     * @returns The summary of the current state of the counter.
+     */
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * Called when the object has disconnected from the delta stream.
+     */
+    protected onDisconnect(): void;
+    /**
+     * Process a counter operation (op).
+     *
+     * @param message - The message to prepare.
+     * @param local - Whether or not the message was sent by the local client.
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be `undefined`.
+     */
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * {@inheritdoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    protected applyStashedOp(op: unknown): void;
+}
+
+export { }