fluid-static.api.md

API Report File for "@fluidframework/fluid-static"

Do not edit this file. It is a report generated by API Extractor.

import { AttachState } from '@fluidframework/container-definitions';
import { BaseContainerRuntimeFactory } from '@fluidframework/aqueduct';
import { ConnectionState } from '@fluidframework/container-definitions';
import { DataObject } from '@fluidframework/aqueduct';
import { IAudience } from '@fluidframework/container-definitions';
import { IChannelFactory } from '@fluidframework/datastore-definitions';
import { IClient } from '@fluidframework/protocol-definitions';
import { IContainer } from '@fluidframework/container-definitions';
import { IContainerRuntime } from '@fluidframework/container-runtime-definitions';
import { ICriticalContainerError } from '@fluidframework/container-definitions';
import { IEvent } from '@fluidframework/common-definitions';
import { IEventProvider } from '@fluidframework/common-definitions';
import { IFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
import { IFluidLoadable } from '@fluidframework/core-interfaces';
import { TypedEventEmitter } from '@fluidframework/common-utils';

// @public
export interface ContainerSchema {
    dynamicObjectTypes?: LoadableObjectClass<any>[];
    initialObjects: LoadableObjectClassRecord;
}

// @public
export type DataObjectClass<T extends IFluidLoadable> = {
    readonly factory: IFluidDataStoreFactory;
} & LoadableObjectCtor<T>;

// @public
export class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
    constructor(schema: ContainerSchema);
    // (undocumented)
    protected containerInitializingFirstTime(runtime: IContainerRuntime): Promise<void>;
}

// @public
export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> implements IFluidContainer {
    constructor(container: IContainer, rootDataObject: IRootDataObject);
    attach(): Promise<string>;
    get attachState(): AttachState;
    connect(): Promise<void>;
    get connectionState(): ConnectionState;
    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
    disconnect(): Promise<void>;
    dispose(): void;
    get disposed(): boolean;
    get initialObjects(): LoadableObjectRecord;
    // @internal
    readonly INTERNAL_CONTAINER_DO_NOT_USE?: () => IContainer;
    get isDirty(): boolean;
}

// @public
export interface IConnection {
    id: string;
    mode: "write" | "read";
}

// @public
export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
    attach(): Promise<string>;
    readonly attachState: AttachState;
    connect(): void;
    readonly connectionState: ConnectionState;
    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
    disconnect(): void;
    dispose(): void;
    readonly disposed: boolean;
    readonly initialObjects: LoadableObjectRecord;
    readonly isDirty: boolean;
}

// @public
export interface IFluidContainerEvents extends IEvent {
    (event: "connected", listener: () => void): void;
    (event: "disconnected", listener: () => void): void;
    (event: "saved", listener: () => void): void;
    (event: "dirty", listener: () => void): void;
    (event: "disposed", listener: (error?: ICriticalContainerError) => void): any;
}

// @public
export interface IMember {
    connections: IConnection[];
    userId: string;
}

// @public
export interface IRootDataObject {
    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
    readonly initialObjects: LoadableObjectRecord;
}

// @public
export interface IServiceAudience<M extends IMember> extends IEventProvider<IServiceAudienceEvents<M>> {
    getMembers(): Map<string, M>;
    getMyself(): Myself<M> | undefined;
}

// @public
export interface IServiceAudienceEvents<M extends IMember> extends IEvent {
    // @eventProperty
    (event: "membersChanged", listener: () => void): void;
    // @eventProperty
    (event: "memberAdded", listener: MemberChangedListener<M>): void;
    // @eventProperty
    (event: "memberRemoved", listener: MemberChangedListener<M>): void;
}

// @public
export type LoadableObjectClass<T extends IFluidLoadable> = DataObjectClass<T> | SharedObjectClass<T>;

// @public
export type LoadableObjectClassRecord = Record<string, LoadableObjectClass<any>>;

// @public
export type LoadableObjectCtor<T extends IFluidLoadable> = new (...args: any[]) => T;

// @public
export type LoadableObjectRecord = Record<string, IFluidLoadable>;

// @public
export type MemberChangedListener<M extends IMember> = (clientId: string, member: M) => void;

// @public
export type Myself<M extends IMember = IMember> = M & {
    currentConnection: string;
};

// @public
export class RootDataObject extends DataObject<{
    InitialState: RootDataObjectProps;
}> implements IRootDataObject {
    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
    protected hasInitialized(): Promise<void>;
    protected initializingFirstTime(props: RootDataObjectProps): Promise<void>;
    get initialObjects(): LoadableObjectRecord;
}

// @public
export interface RootDataObjectProps {
    initialObjects: LoadableObjectClassRecord;
}

// @public
export abstract class ServiceAudience<M extends IMember = IMember> extends TypedEventEmitter<IServiceAudienceEvents<M>> implements IServiceAudience<M> {
    constructor(
    container: IContainer);
    protected readonly audience: IAudience;
    protected readonly container: IContainer;
    protected abstract createServiceMember(audienceMember: IClient): M;
    getMembers(): Map<string, M>;
    getMyself(): Myself<M> | undefined;
    protected lastMembers: Map<string, M>;
    protected shouldIncludeAsMember(member: IClient): boolean;
}

// @public
export type SharedObjectClass<T extends IFluidLoadable> = {
    readonly getFactory: () => IChannelFactory;
} & LoadableObjectCtor<T>;