@fluidframework/register-collection 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.204906

package/dist/register-collection-alpha.d.ts

@@ -0,0 +1,169 @@
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } 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';
+
+/**
+ * {@inheritDoc IConsensusRegisterCollection}
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollection<T> extends SharedObject<IConsensusRegisterCollectionEvents> implements IConsensusRegisterCollection<T> {
+    /**
+     * Create a new consensus register collection
+     *
+     * @param runtime - data store runtime the new consensus register collection belongs to
+     * @param id - optional name of the consensus register collection
+     * @returns newly create consensus register collection (but not attached yet)
+     */
+    static create<T>(runtime: IFluidDataStoreRuntime, id?: string): ConsensusRegisterCollection<T>;
+    /**
+     * Get a factory for ConsensusRegisterCollection to register with the data store.
+     *
+     * @returns a factory that creates and load ConsensusRegisterCollection
+     */
+    static getFactory(): ConsensusRegisterCollectionFactory;
+    private readonly data;
+    /**
+     * Constructs a new consensus register collection. If the object is non-local an id and service interfaces will
+     * be provided
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Creates a new register or writes a new value.
+     * Returns a promise that will resolve when the write is acked.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Returns the most recent local value of a register.
+     * @param key - The key to read
+     * @param readPolicy - The ReadPolicy to apply. Defaults to Atomic.
+     */
+    read(key: string, readPolicy?: ReadPolicy): T | undefined;
+    readVersions(key: string): T[] | undefined;
+    keys(): string[];
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    protected onDisconnect(): void;
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    private readAtomic;
+    /**
+     * Process an inbound write op
+     * @param key - Key that was written to
+     * @param value - Incoming value
+     * @param refSeq - RefSeq at the time of write on the remote client
+     * @param sequenceNumber - Sequence Number of this write op
+     * @param local - Did this write originate on this client
+     */
+    private processInboundWrite;
+    private stringify;
+    private parse;
+    protected applyStashedOp(): () => void;
+}
+
+/**
+ * The factory that defines the consensus queue.
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollectionFactory implements IConsensusRegisterCollectionFactory {
+    static Type: string;
+    static readonly Attributes: IChannelAttributes;
+    get type(): string;
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * A distributed data structure that holds a set of registers with update
+ * versions. On concurrent updates, a register internally stores all possible versions of a value by using reference
+ * sequence number of the incoming update.
+ *
+ * Using all the stored versions, we can then distinguish amongst different read policies. Below are the policies
+ * we support:
+ *
+ * Atomic: Atomicity requires a linearizable register. A linearizable register behaves as if there is only a single
+ * copy of the data, and that every operation appears to take effect atomically at one point in time. This definition
+ * implies that operations are executed in an well-defined order. On a concurrent update, we perform a compare-and-set
+ * operation, where we compare a register sequence number with the incoming reference sequence number.
+ * The earliest operation overwriting prior sequence numbers wins since every client reaches to an agreement on
+ * the value. So we can safely return the first value.
+ *
+ * LWW: The last write to a key always wins.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollection<T = any> extends ISharedObject<IConsensusRegisterCollectionEvents> {
+    /**
+     * Attempts to write a register with a value. Returns a promise to indicate the roundtrip completion.
+     * For a non existent register, it will attempt to create a new register with the specified value.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Retrieves the agreed upon value for the register based on policy. Returns undefined if not present.
+     */
+    read(key: string, policy?: ReadPolicy): T | undefined;
+    /**
+     * Retrives all concurrent versions. Undefined if not present.
+     */
+    readVersions(key: string): T[] | undefined;
+    /**
+     * Returns the keys.
+     */
+    keys(): string[];
+}
+
+/**
+ * Events emitted by {@link IConsensusRegisterCollection}.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionEvents extends ISharedObjectEvents {
+    (event: "atomicChanged" | "versionChanged", listener: (key: string, value: any, local: boolean) => void): any;
+}
+
+/**
+ * Consensus Register Collection channel factory interface
+ *
+ * Extends the base IChannelFactory to return a more definite type of IConsensusRegisterCollection
+ * Use for the runtime to create and load distributed data structure by type name of each channel.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionFactory extends IChannelFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(document: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * Read policies used when reading the map value.
+ *
+ * @public
+ */
+export declare enum ReadPolicy {
+    Atomic = 0,
+    LWW = 1
+}
+
+export { }

package/dist/register-collection-beta.d.ts

@@ -0,0 +1,169 @@
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } 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';
+
+/**
+ * {@inheritDoc IConsensusRegisterCollection}
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollection<T> extends SharedObject<IConsensusRegisterCollectionEvents> implements IConsensusRegisterCollection<T> {
+    /**
+     * Create a new consensus register collection
+     *
+     * @param runtime - data store runtime the new consensus register collection belongs to
+     * @param id - optional name of the consensus register collection
+     * @returns newly create consensus register collection (but not attached yet)
+     */
+    static create<T>(runtime: IFluidDataStoreRuntime, id?: string): ConsensusRegisterCollection<T>;
+    /**
+     * Get a factory for ConsensusRegisterCollection to register with the data store.
+     *
+     * @returns a factory that creates and load ConsensusRegisterCollection
+     */
+    static getFactory(): ConsensusRegisterCollectionFactory;
+    private readonly data;
+    /**
+     * Constructs a new consensus register collection. If the object is non-local an id and service interfaces will
+     * be provided
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Creates a new register or writes a new value.
+     * Returns a promise that will resolve when the write is acked.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Returns the most recent local value of a register.
+     * @param key - The key to read
+     * @param readPolicy - The ReadPolicy to apply. Defaults to Atomic.
+     */
+    read(key: string, readPolicy?: ReadPolicy): T | undefined;
+    readVersions(key: string): T[] | undefined;
+    keys(): string[];
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    protected onDisconnect(): void;
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    private readAtomic;
+    /**
+     * Process an inbound write op
+     * @param key - Key that was written to
+     * @param value - Incoming value
+     * @param refSeq - RefSeq at the time of write on the remote client
+     * @param sequenceNumber - Sequence Number of this write op
+     * @param local - Did this write originate on this client
+     */
+    private processInboundWrite;
+    private stringify;
+    private parse;
+    protected applyStashedOp(): () => void;
+}
+
+/**
+ * The factory that defines the consensus queue.
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollectionFactory implements IConsensusRegisterCollectionFactory {
+    static Type: string;
+    static readonly Attributes: IChannelAttributes;
+    get type(): string;
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * A distributed data structure that holds a set of registers with update
+ * versions. On concurrent updates, a register internally stores all possible versions of a value by using reference
+ * sequence number of the incoming update.
+ *
+ * Using all the stored versions, we can then distinguish amongst different read policies. Below are the policies
+ * we support:
+ *
+ * Atomic: Atomicity requires a linearizable register. A linearizable register behaves as if there is only a single
+ * copy of the data, and that every operation appears to take effect atomically at one point in time. This definition
+ * implies that operations are executed in an well-defined order. On a concurrent update, we perform a compare-and-set
+ * operation, where we compare a register sequence number with the incoming reference sequence number.
+ * The earliest operation overwriting prior sequence numbers wins since every client reaches to an agreement on
+ * the value. So we can safely return the first value.
+ *
+ * LWW: The last write to a key always wins.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollection<T = any> extends ISharedObject<IConsensusRegisterCollectionEvents> {
+    /**
+     * Attempts to write a register with a value. Returns a promise to indicate the roundtrip completion.
+     * For a non existent register, it will attempt to create a new register with the specified value.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Retrieves the agreed upon value for the register based on policy. Returns undefined if not present.
+     */
+    read(key: string, policy?: ReadPolicy): T | undefined;
+    /**
+     * Retrives all concurrent versions. Undefined if not present.
+     */
+    readVersions(key: string): T[] | undefined;
+    /**
+     * Returns the keys.
+     */
+    keys(): string[];
+}
+
+/**
+ * Events emitted by {@link IConsensusRegisterCollection}.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionEvents extends ISharedObjectEvents {
+    (event: "atomicChanged" | "versionChanged", listener: (key: string, value: any, local: boolean) => void): any;
+}
+
+/**
+ * Consensus Register Collection channel factory interface
+ *
+ * Extends the base IChannelFactory to return a more definite type of IConsensusRegisterCollection
+ * Use for the runtime to create and load distributed data structure by type name of each channel.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionFactory extends IChannelFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(document: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * Read policies used when reading the map value.
+ *
+ * @public
+ */
+export declare enum ReadPolicy {
+    Atomic = 0,
+    LWW = 1
+}
+
+export { }

package/dist/register-collection-public.d.ts

@@ -0,0 +1,169 @@
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } 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';
+
+/**
+ * {@inheritDoc IConsensusRegisterCollection}
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollection<T> extends SharedObject<IConsensusRegisterCollectionEvents> implements IConsensusRegisterCollection<T> {
+    /**
+     * Create a new consensus register collection
+     *
+     * @param runtime - data store runtime the new consensus register collection belongs to
+     * @param id - optional name of the consensus register collection
+     * @returns newly create consensus register collection (but not attached yet)
+     */
+    static create<T>(runtime: IFluidDataStoreRuntime, id?: string): ConsensusRegisterCollection<T>;
+    /**
+     * Get a factory for ConsensusRegisterCollection to register with the data store.
+     *
+     * @returns a factory that creates and load ConsensusRegisterCollection
+     */
+    static getFactory(): ConsensusRegisterCollectionFactory;
+    private readonly data;
+    /**
+     * Constructs a new consensus register collection. If the object is non-local an id and service interfaces will
+     * be provided
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Creates a new register or writes a new value.
+     * Returns a promise that will resolve when the write is acked.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Returns the most recent local value of a register.
+     * @param key - The key to read
+     * @param readPolicy - The ReadPolicy to apply. Defaults to Atomic.
+     */
+    read(key: string, readPolicy?: ReadPolicy): T | undefined;
+    readVersions(key: string): T[] | undefined;
+    keys(): string[];
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    protected onDisconnect(): void;
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    private readAtomic;
+    /**
+     * Process an inbound write op
+     * @param key - Key that was written to
+     * @param value - Incoming value
+     * @param refSeq - RefSeq at the time of write on the remote client
+     * @param sequenceNumber - Sequence Number of this write op
+     * @param local - Did this write originate on this client
+     */
+    private processInboundWrite;
+    private stringify;
+    private parse;
+    protected applyStashedOp(): () => void;
+}
+
+/**
+ * The factory that defines the consensus queue.
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollectionFactory implements IConsensusRegisterCollectionFactory {
+    static Type: string;
+    static readonly Attributes: IChannelAttributes;
+    get type(): string;
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * A distributed data structure that holds a set of registers with update
+ * versions. On concurrent updates, a register internally stores all possible versions of a value by using reference
+ * sequence number of the incoming update.
+ *
+ * Using all the stored versions, we can then distinguish amongst different read policies. Below are the policies
+ * we support:
+ *
+ * Atomic: Atomicity requires a linearizable register. A linearizable register behaves as if there is only a single
+ * copy of the data, and that every operation appears to take effect atomically at one point in time. This definition
+ * implies that operations are executed in an well-defined order. On a concurrent update, we perform a compare-and-set
+ * operation, where we compare a register sequence number with the incoming reference sequence number.
+ * The earliest operation overwriting prior sequence numbers wins since every client reaches to an agreement on
+ * the value. So we can safely return the first value.
+ *
+ * LWW: The last write to a key always wins.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollection<T = any> extends ISharedObject<IConsensusRegisterCollectionEvents> {
+    /**
+     * Attempts to write a register with a value. Returns a promise to indicate the roundtrip completion.
+     * For a non existent register, it will attempt to create a new register with the specified value.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Retrieves the agreed upon value for the register based on policy. Returns undefined if not present.
+     */
+    read(key: string, policy?: ReadPolicy): T | undefined;
+    /**
+     * Retrives all concurrent versions. Undefined if not present.
+     */
+    readVersions(key: string): T[] | undefined;
+    /**
+     * Returns the keys.
+     */
+    keys(): string[];
+}
+
+/**
+ * Events emitted by {@link IConsensusRegisterCollection}.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionEvents extends ISharedObjectEvents {
+    (event: "atomicChanged" | "versionChanged", listener: (key: string, value: any, local: boolean) => void): any;
+}
+
+/**
+ * Consensus Register Collection channel factory interface
+ *
+ * Extends the base IChannelFactory to return a more definite type of IConsensusRegisterCollection
+ * Use for the runtime to create and load distributed data structure by type name of each channel.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionFactory extends IChannelFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(document: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * Read policies used when reading the map value.
+ *
+ * @public
+ */
+export declare enum ReadPolicy {
+    Atomic = 0,
+    LWW = 1
+}
+
+export { }

package/dist/register-collection-untrimmed.d.ts

@@ -0,0 +1,169 @@
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } 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';
+
+/**
+ * {@inheritDoc IConsensusRegisterCollection}
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollection<T> extends SharedObject<IConsensusRegisterCollectionEvents> implements IConsensusRegisterCollection<T> {
+    /**
+     * Create a new consensus register collection
+     *
+     * @param runtime - data store runtime the new consensus register collection belongs to
+     * @param id - optional name of the consensus register collection
+     * @returns newly create consensus register collection (but not attached yet)
+     */
+    static create<T>(runtime: IFluidDataStoreRuntime, id?: string): ConsensusRegisterCollection<T>;
+    /**
+     * Get a factory for ConsensusRegisterCollection to register with the data store.
+     *
+     * @returns a factory that creates and load ConsensusRegisterCollection
+     */
+    static getFactory(): ConsensusRegisterCollectionFactory;
+    private readonly data;
+    /**
+     * Constructs a new consensus register collection. If the object is non-local an id and service interfaces will
+     * be provided
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Creates a new register or writes a new value.
+     * Returns a promise that will resolve when the write is acked.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Returns the most recent local value of a register.
+     * @param key - The key to read
+     * @param readPolicy - The ReadPolicy to apply. Defaults to Atomic.
+     */
+    read(key: string, readPolicy?: ReadPolicy): T | undefined;
+    readVersions(key: string): T[] | undefined;
+    keys(): string[];
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    protected onDisconnect(): void;
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    private readAtomic;
+    /**
+     * Process an inbound write op
+     * @param key - Key that was written to
+     * @param value - Incoming value
+     * @param refSeq - RefSeq at the time of write on the remote client
+     * @param sequenceNumber - Sequence Number of this write op
+     * @param local - Did this write originate on this client
+     */
+    private processInboundWrite;
+    private stringify;
+    private parse;
+    protected applyStashedOp(): () => void;
+}
+
+/**
+ * The factory that defines the consensus queue.
+ *
+ * @public
+ */
+export declare class ConsensusRegisterCollectionFactory implements IConsensusRegisterCollectionFactory {
+    static Type: string;
+    static readonly Attributes: IChannelAttributes;
+    get type(): string;
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * A distributed data structure that holds a set of registers with update
+ * versions. On concurrent updates, a register internally stores all possible versions of a value by using reference
+ * sequence number of the incoming update.
+ *
+ * Using all the stored versions, we can then distinguish amongst different read policies. Below are the policies
+ * we support:
+ *
+ * Atomic: Atomicity requires a linearizable register. A linearizable register behaves as if there is only a single
+ * copy of the data, and that every operation appears to take effect atomically at one point in time. This definition
+ * implies that operations are executed in an well-defined order. On a concurrent update, we perform a compare-and-set
+ * operation, where we compare a register sequence number with the incoming reference sequence number.
+ * The earliest operation overwriting prior sequence numbers wins since every client reaches to an agreement on
+ * the value. So we can safely return the first value.
+ *
+ * LWW: The last write to a key always wins.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollection<T = any> extends ISharedObject<IConsensusRegisterCollectionEvents> {
+    /**
+     * Attempts to write a register with a value. Returns a promise to indicate the roundtrip completion.
+     * For a non existent register, it will attempt to create a new register with the specified value.
+     *
+     * @returns Promise<true> if write was non-concurrent
+     */
+    write(key: string, value: T): Promise<boolean>;
+    /**
+     * Retrieves the agreed upon value for the register based on policy. Returns undefined if not present.
+     */
+    read(key: string, policy?: ReadPolicy): T | undefined;
+    /**
+     * Retrives all concurrent versions. Undefined if not present.
+     */
+    readVersions(key: string): T[] | undefined;
+    /**
+     * Returns the keys.
+     */
+    keys(): string[];
+}
+
+/**
+ * Events emitted by {@link IConsensusRegisterCollection}.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionEvents extends ISharedObjectEvents {
+    (event: "atomicChanged" | "versionChanged", listener: (key: string, value: any, local: boolean) => void): any;
+}
+
+/**
+ * Consensus Register Collection channel factory interface
+ *
+ * Extends the base IChannelFactory to return a more definite type of IConsensusRegisterCollection
+ * Use for the runtime to create and load distributed data structure by type name of each channel.
+ *
+ * @public
+ */
+export declare interface IConsensusRegisterCollectionFactory extends IChannelFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(document: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IConsensusRegisterCollection>;
+    create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection;
+}
+
+/**
+ * Read policies used when reading the map value.
+ *
+ * @public
+ */
+export declare enum ReadPolicy {
+    Atomic = 0,
+    LWW = 1
+}
+
+export { }

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.34.9"
+      "packageVersion": "7.38.0"
     }
   ]
 }