@fluidframework/container-definitions 2.0.0-dev.7.4.0.215747 → 2.0.0-dev.7.4.0.216897

package/dist/container-definitions-alpha.d.ts

@@ -5,1469 +5,147 @@
  */
 
 import { EventEmitter } from 'events';
-import { FluidObject } from '@fluidframework/core-interfaces';
-import { IAnyDriverError } from '@fluidframework/driver-definitions';
 import { IClient } from '@fluidframework/protocol-definitions';
 import { IClientConfiguration } from '@fluidframework/protocol-definitions';
 import { IClientDetails } from '@fluidframework/protocol-definitions';
-import { IDisposable } from '@fluidframework/core-interfaces';
 import { IDocumentMessage } from '@fluidframework/protocol-definitions';
-import { IDocumentStorageService } from '@fluidframework/driver-definitions';
-import { IErrorBase } from '@fluidframework/core-interfaces';
-import { IErrorEvent } from '@fluidframework/core-interfaces';
-import { IEvent } from '@fluidframework/core-interfaces';
-import { IEventProvider } from '@fluidframework/core-interfaces';
-import { IFluidRouter } from '@fluidframework/core-interfaces';
-import { IGenericError } from '@fluidframework/core-interfaces';
 import { IQuorumClients } from '@fluidframework/protocol-definitions';
-import { IRequest } from '@fluidframework/core-interfaces';
-import { IResolvedUrl } from '@fluidframework/driver-definitions';
-import { IResponse } from '@fluidframework/core-interfaces';
 import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
 import { ISequencedProposal } from '@fluidframework/protocol-definitions';
 import { ISignalMessage } from '@fluidframework/protocol-definitions';
 import { ISnapshotTree } from '@fluidframework/protocol-definitions';
 import { ISummaryContent } from '@fluidframework/protocol-definitions';
 import { ISummaryTree } from '@fluidframework/protocol-definitions';
-import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
-import { IThrottlingWarning } from '@fluidframework/core-interfaces';
 import { ITokenClaims } from '@fluidframework/protocol-definitions';
-import { IUsageError } from '@fluidframework/core-interfaces';
 import { IVersion } from '@fluidframework/protocol-definitions';
 import { MessageType } from '@fluidframework/protocol-definitions';
 
-/**
- * The attachment state of some Fluid data (e.g. a container or data store), denoting whether it is uploaded to the
- * service.  The transition from detached to attached state is a one-way transition.
- * @public
- */
-export declare enum AttachState {
-    /**
-     * In detached state, the data is only present on the local client's machine.  It has not yet been uploaded
-     * to the service.
-     */
-    Detached = "Detached",
-    /**
-     * In attaching state, the data has started the upload to the service, but has not yet completed.
-     */
-    Attaching = "Attaching",
-    /**
-     * In attached state, the data has completed upload to the service.  It can be accessed by other clients after
-     * reaching attached state.
-     */
-    Attached = "Attached"
-}
+/* Excluded from this release type: AttachState */
 
-/**
- * Namespace for the different connection states a container can be in.
- * PLEASE NOTE: The sequence of the numerical values does no correspond to the typical connection state progression.
- * @public
- */
-export declare namespace ConnectionState {
-    /**
-     * The container is not connected to the delta server.
-     * Note - When in this state the container may be about to reconnect,
-     * or may remain disconnected until explicitly told to connect.
-     */
-    export type Disconnected = 0;
-    /**
-     * The container is disconnected but actively trying to establish a new connection.
-     * PLEASE NOTE that this numerical value falls out of the order you may expect for this state.
-     */
-    export type EstablishingConnection = 3;
-    /**
-     * The container has an inbound connection only, and is catching up to the latest known state from the service.
-     */
-    export type CatchingUp = 1;
-    /**
-     * The container is fully connected and syncing.
-     */
-    export type Connected = 2;
-}
+/* Excluded from this release type: ConnectionState */
 
-/**
- * Type defining the different states of connectivity a Container can be in.
- * @public
- */
-export declare type ConnectionState = ConnectionState.Disconnected | ConnectionState.EstablishingConnection | ConnectionState.CatchingUp | ConnectionState.Connected;
+/* Excluded from this release type: ContainerErrorType */
 
-/**
- * Different error types the Container may report out to the Host.
- *
- * @deprecated ContainerErrorType is being deprecated as a public export. Please use {@link ContainerErrorTypes#clientSessionExpiredError} instead.
- * @public
- */
-export declare enum ContainerErrorType {
-    /**
-     * Some error, most likely an exception caught by runtime and propagated to container as critical error
-     */
-    genericError = "genericError",
-    /**
-     * Throttling error from server. Server is busy and is asking not to reconnect for some time
-     */
-    throttlingError = "throttlingError",
-    /**
-     * Data loss error detected by Container / DeltaManager. Likely points to storage issue.
-     */
-    dataCorruptionError = "dataCorruptionError",
-    /**
-     * Error encountered when processing an operation. May correlate with data corruption.
-     */
-    dataProcessingError = "dataProcessingError",
-    /**
-     * Error indicating an API is being used improperly resulting in an invalid operation.
-     */
-    usageError = "usageError",
-    /**
-     * Error indicating an client session has expired. Currently this only happens when GC is allowed on a document and
-     * aids in safely deleting unused objects.
-     */
-    clientSessionExpiredError = "clientSessionExpiredError"
-}
+/* Excluded from this release type: ContainerErrorTypes */
 
-/**
- * Different error types the ClientSession may report out to the Host.
- * @public
- */
-export declare const ContainerErrorTypes: {
-    /**
-     * Error indicating an client session has expired. Currently this only happens when GC is allowed on a document and
-     * aids in safely deleting unused objects.
-     */
-    readonly clientSessionExpiredError: "clientSessionExpiredError";
-    readonly genericError: "genericError";
-    readonly throttlingError: "throttlingError";
-    readonly dataCorruptionError: "dataCorruptionError";
-    readonly dataProcessingError: "dataProcessingError";
-    readonly usageError: "usageError";
-};
+/* Excluded from this release type: ContainerWarning */
 
-/**
- * @public
- */
-export declare type ContainerErrorTypes = (typeof ContainerErrorTypes)[keyof typeof ContainerErrorTypes];
+/* Excluded from this release type: FluidObject */
 
-/**
- * Represents warnings raised on container.
- * @public
- */
-export declare interface ContainerWarning extends IErrorBase {
-    /**
-     * Whether this error has already been logged. Used to avoid logging errors twice.
-     *
-     * @defaultValue `false`
-     */
-    logged?: boolean;
-}
+/* Excluded from this release type: IAnyDriverError */
 
-/**
- * Audience represents all clients connected to the op stream, both read-only and read/write.
- *
- * See {@link https://nodejs.org/api/events.html#class-eventemitter | here} for an overview of the `EventEmitter`
- * class.
- * @public
- */
-export declare interface IAudience extends EventEmitter {
-    /**
-     * See {@link https://nodejs.dev/learn/the-nodejs-event-emitter | here} for an overview of `EventEmitter.on`.
-     */
-    on(event: "addMember" | "removeMember", listener: (clientId: string, client: IClient) => void): this;
-    /**
-     * List all clients connected to the op stream, keyed off their clientId
-     */
-    getMembers(): Map<string, IClient>;
-    /**
-     * Get details about the connected client with the specified clientId,
-     * or undefined if the specified client isn't connected
-     */
-    getMember(clientId: string): IClient | undefined;
-}
+/* Excluded from this release type: IAudience */
 
-/**
- * Manages the state and the members for {@link IAudience}
- * @public
- */
-export declare interface IAudienceOwner extends IAudience {
-    /**
-     * Adds a new client to the audience
-     */
-    addMember(clientId: string, details: IClient): void;
-    /**
-     * Removes a client from the audience. Only emits an event if a client is actually removed
-     * @returns if a client was removed from the audience
-     */
-    removeMember(clientId: string): boolean;
-}
+/* Excluded from this release type: IAudienceOwner */
 
-/**
- * Payload type for IContainerContext.submitBatchFn()
- * @public
- */
-export declare interface IBatchMessage {
-    contents?: string;
-    metadata: Record<string, unknown> | undefined;
-    compression?: string;
-    referenceSequenceNumber?: number;
-}
+/* Excluded from this release type: IBatchMessage */
 
-/**
- * Fluid code loader resolves a code module matching the document schema, i.e. code details, such as
- * a package name and package version range.
- * @public
- */
-export declare interface ICodeDetailsLoader extends Partial<IProvideFluidCodeDetailsComparer> {
-    /**
-     * Load the code module (package) that can interact with the document.
-     *
-     * @param source - Code proposal that articulates the current schema the document is written in.
-     * @returns Code module entry point along with the code details associated with it.
-     */
-    load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
-}
+/* Excluded from this release type: ICodeDetailsLoader */
 
-/**
- * Contract representing the result of a newly established connection to the server for syncing deltas.
- * @public
- */
-export declare interface IConnectionDetails {
-    clientId: string;
-    claims: ITokenClaims;
-    serviceConfiguration: IClientConfiguration;
-    /**
-     * Last known sequence number to ordering service at the time of connection.
-     *
-     * @remarks
-     *
-     * It may lap actual last sequence number (quite a bit, if container is very active).
-     * But it's the best information for client to figure out how far it is behind, at least
-     * for "read" connections. "write" connections may use own "join" op to similar information,
-     * that is likely to be more up-to-date.
-     */
-    checkpointSequenceNumber: number | undefined;
-}
+/* Excluded from this release type: IConnectionDetails */
 
-/**
- * The Host's view of a Container and its connection to storage
- * @public
- */
-export declare interface IContainer extends IEventProvider<IContainerEvents>, IFluidRouter {
-    /**
-     * The Delta Manager supporting the op stream for this Container
-     */
-    deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
-    /**
-     * The collection of write clients which were connected as of the current sequence number.
-     * Also contains a map of key-value pairs that must be agreed upon by all clients before being accepted.
-     */
-    getQuorum(): IQuorumClients;
-    /**
-     * Represents the resolved url to the Container.
-     * Will be undefined only when the container is in the {@link AttachState.Detached | detatched} state.
-     */
-    resolvedUrl: IResolvedUrl | undefined;
-    /**
-     * Indicates the attachment state of the container to a host service.
-     */
-    readonly attachState: AttachState;
-    /**
-     * Get the code details that are currently specified for the container.
-     * @returns The current code details if any are specified, undefined if none are specified.
-     */
-    getSpecifiedCodeDetails(): IFluidCodeDetails | undefined;
-    /**
-     * Get the code details that were used to load the container.
-     * @returns The code details that were used to load the container if it is loaded, undefined if it is not yet
-     * loaded.
-     */
-    getLoadedCodeDetails(): IFluidCodeDetails | undefined;
-    /**
-     * Returns true if the container has been closed and/or disposed, otherwise false.
-     */
-    readonly closed: boolean;
-    /**
-     * Returns true if the container has been disposed, otherwise false.
-     */
-    readonly disposed?: boolean;
-    /**
-     * Whether or not there are any local changes that have not been saved.
-     */
-    readonly isDirty: boolean;
-    /**
-     * Disposes the container. If not already closed, this acts as a closure and then disposes runtime resources.
-     * The container is not expected to be used anymore once it is disposed.
-     *
-     * @param error - If the container is being disposed due to error, this provides details about the error that
-     * resulted in disposing it.
-     */
-    dispose(error?: ICriticalContainerError): void;
-    /**
-     * Closes the container.
-     *
-     * @param error - If the container is being closed due to error, this provides details about the error that
-     * resulted in closing it.
-     */
-    close(error?: ICriticalContainerError): void;
-    /**
-     * Propose new code details that define the code to be loaded for this container's runtime.
-     *
-     * The returned promise will be true when the proposal is accepted, and false if the proposal is rejected.
-     */
-    proposeCodeDetails(codeDetails: IFluidCodeDetails): Promise<boolean>;
-    /**
-     * Attaches the Container to the Container specified by the given Request.
-     *
-     * @privateRemarks
-     *
-     * TODO - in the case of failure options should give a retry policy.
-     * Or some continuation function that allows attachment to a secondary document.
-     */
-    attach(request: IRequest, attachProps?: {
-        deltaConnection?: "none" | "delayed";
-    }): Promise<void>;
-    /**
-     * Extract a snapshot of the container as long as it is in detached state. Calling this on an attached container
-     * is an error.
-     */
-    serialize(): string;
-    /**
-     * Get an absolute URL for a provided container-relative request URL.
-     * If the container is not attached, this will return undefined.
-     *
-     * @param relativeUrl - A container-relative request URL.
-     */
-    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
-    /**
-     * @deprecated Requesting will not be supported in a future major release.
-     * Instead, access the objects in a Fluid Container using entryPoint, and then navigate from there using
-     * app-specific logic (e.g. retrieving handles from the entryPoint's DDSes, or a container's entryPoint object
-     * could implement a request paradigm itself)
-     *
-     * IMPORTANT: This overload is provided for back-compat where IContainer.request(\{ url: "/" \}) is already implemented and used.
-     * The functionality it can provide (if the Container implementation is built for it) is redundant with @see {@link IContainer.getEntryPoint}.
-     *
-     * Refer to Removing-IFluidRouter.md for details on migrating from the request pattern to using entryPoint.
-     *
-     * @param request - Only requesting \{ url: "/" \} is supported, requesting arbitrary URLs is deprecated.
-     */
-    request(request: {
-        url: "/";
-        headers?: undefined;
-    }): Promise<IResponse>;
-    /**
-     * Issue a request against the container for a resource.
-     * @param request - The request to be issued against the container
-     *
-     * @deprecated Requesting an arbitrary URL with headers will not be supported in a future major release.
-     * Instead, access the objects in a Fluid Container using entryPoint, and then navigate from there using
-     * app-specific logic (e.g. retrieving handles from the entryPoint's DDSes, or a container's entryPoint object
-     * could implement a request paradigm itself)
-     *
-     * Refer to Removing-IFluidRouter.md for details on migrating from the request pattern to using entryPoint.
-     */
-    request(request: IRequest): Promise<IResponse>;
-    /**
-     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
-     */
-    readonly IFluidRouter: IFluidRouter;
-    /**
-     * Provides the current state of the container's connection to the ordering service.
-     *
-     * @remarks Consumers can listen for state changes via the "connected" and "disconnected" events.
-     */
-    readonly connectionState: ConnectionState;
-    /**
-     * Attempts to connect the container to the delta stream and process ops.
-     *
-     * @remarks
-     *
-     * {@link IContainer.connectionState} will be set to {@link (ConnectionState:namespace).Connected}, and the
-     * "connected" event will be fired if/when connection succeeds.
-     */
-    connect(): void;
-    /**
-     * Disconnects the container from the delta stream and stops processing ops.
-     *
-     * @remarks
-     *
-     * {@link IContainer.connectionState} will be set to {@link (ConnectionState:namespace).Disconnected}, and the
-     * "disconnected" event will be fired when disconnection completes.
-     */
-    disconnect(): void;
-    /**
-     * The audience information for all clients currently associated with the document in the current session.
-     */
-    readonly audience: IAudience;
-    /**
-     * The server provided ID of the client.
-     *
-     * Set once {@link IContainer.connectionState} is {@link (ConnectionState:namespace).Connected},
-     * otherwise will be `undefined`.
-     */
-    readonly clientId?: string | undefined;
-    /**
-     * Tells if container is in read-only mode.
-     *
-     * @remarks
-     *
-     * Data stores should listen for "readonly" notifications and disallow user making changes to data stores.
-     * Readonly state can be because of no storage write permission,
-     * or due to host forcing readonly mode for container.
-     *
-     * We do not differentiate here between no write access to storage vs. host disallowing changes to container -
-     * in all cases container runtime and data stores should respect readonly state and not allow local changes.
-     *
-     * It is undefined if we have not yet established websocket connection
-     * and do not know if user has write access to a file.
-     */
-    readonly readOnlyInfo: ReadOnlyInfo;
-    /**
-     * Allows the host to have the container force to be in read-only mode
-     * @param readonly - Boolean that toggles if read-only policies will be enforced
-     * @alpha
-     */
-    forceReadonly?(readonly: boolean): any;
-    /**
-     * Exposes the entryPoint for the container.
-     * Use this as the primary way of getting access to the user-defined logic within the container.
-     */
-    getEntryPoint(): Promise<FluidObject | undefined>;
-}
+/* Excluded from this release type: IContainer */
 
-/**
- * IContainerContext is fundamentally just the set of things that an IRuntimeFactory (and IRuntime) will consume from the
- * loader layer.  It gets passed into the IRuntimeFactory.instantiateRuntime call.  Only include members on this interface
- * if you intend them to be consumed/called from the runtime layer.
- * @public
- */
-export declare interface IContainerContext {
-    readonly options: ILoaderOptions;
-    readonly clientId: string | undefined;
-    readonly clientDetails: IClientDetails;
-    readonly storage: IDocumentStorageService;
-    readonly connected: boolean;
-    readonly baseSnapshot: ISnapshotTree | undefined;
-    /**
-     * @deprecated Please use submitBatchFn & submitSummaryFn
-     */
-    readonly submitFn: (type: MessageType, contents: any, batch: boolean, appData?: any) => number;
-    /**
-     * @returns clientSequenceNumber of last message in a batch
-     */
-    readonly submitBatchFn: (batch: IBatchMessage[], referenceSequenceNumber?: number) => number;
-    readonly submitSummaryFn: (summaryOp: ISummaryContent, referenceSequenceNumber?: number) => number;
-    readonly submitSignalFn: (contents: any, targetClientId?: string) => void;
-    readonly disposeFn?: (error?: ICriticalContainerError) => void;
-    readonly closeFn: (error?: ICriticalContainerError) => void;
-    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
-    readonly quorum: IQuorumClients;
-    /**
-     * @deprecated This method is provided as a migration tool for customers currently reading the code details
-     * from within the Container by directly accessing the Quorum proposals.  The code details should not be accessed
-     * from within the Container as this requires coupling between the container contents and the code loader.
-     * Direct access to Quorum proposals will be removed in an upcoming release, and in a further future release this
-     * migration tool will be removed.
-     */
-    getSpecifiedCodeDetails?(): IFluidCodeDetails | undefined;
-    readonly audience: IAudience | undefined;
-    readonly loader: ILoader;
-    readonly taggedLogger: ITelemetryBaseLogger;
-    pendingLocalState?: unknown;
-    /**
-     * Ambient services provided with the context
-     */
-    readonly scope: FluidObject;
-    /**
-     * Get an absolute url for a provided container-relative request.
-     * @param relativeUrl - A relative request within the container
-     *
-     * TODO: Optional for backwards compatibility. Make non-optional in version 0.19
-     */
-    getAbsoluteUrl?(relativeUrl: string): Promise<string | undefined>;
-    /**
-     * Indicates the attachment state of the container to a host service.
-     */
-    readonly attachState: AttachState;
-    getLoadedFromVersion(): IVersion | undefined;
-    updateDirtyContainerState(dirty: boolean): void;
-    readonly supportedFeatures?: ReadonlyMap<string, unknown>;
-    /**
-     * WARNING: this id is meant for telemetry usages ONLY, not recommended for other consumption
-     * This id is not supposed to be exposed anywhere else. It is dependant on usage or drivers
-     * and scenarios which can change in the future.
-     * @deprecated 2.0.0-internal.5.2.0 - The docId is already logged by the {@link IContainerContext.taggedLogger} for
-     * telemetry purposes, so this is generally unnecessary for telemetry.
-     * If the id is needed for other purposes it should be passed to the consumer explicitly.
-     *
-     * @privateremarks Tracking in AB#5714
-     */
-    readonly id: string;
-}
+/* Excluded from this release type: IContainerContext */
 
-/**
- * Events emitted by the {@link IContainer} "upwards" to the Loader and Host.
- * @public
- */
-export declare interface IContainerEvents extends IEvent {
-    /**
-     * Emitted when the readonly state of the container changes.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `readonly`: Whether or not the container is now in a readonly state.
-     *
-     * @see {@link IContainer.readOnlyInfo}
-     */
-    (event: "readonly", listener: (readonly: boolean) => void): void;
-    /**
-     * Emitted when the {@link IContainer} completes connecting to the Fluid service.
-     *
-     * @remarks Reflects connection state changes against the (delta) service acknowledging ops/edits.
-     *
-     * @see
-     *
-     * - {@link IContainer.connectionState}
-     *
-     * - {@link IContainer.connect}
-     */
-    (event: "connected", listener: (clientId: string) => void): any;
-    /**
-     * Fires when new container code details have been proposed, prior to acceptance.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `codeDetails`: The code details being proposed.
-     *
-     * - `proposal`: NOT RECOMMENDED FOR USE.
-     *
-     * @see {@link IContainer.proposeCodeDetails}
-     */
-    (event: "codeDetailsProposed", listener: (codeDetails: IFluidCodeDetails, proposal: ISequencedProposal) => void): any;
-    /**
-     * Emitted when the {@link IContainer} becomes disconnected from the Fluid service.
-     *
-     * @remarks Reflects connection state changes against the (delta) service acknowledging ops/edits.
-     *
-     * @see
-     *
-     * - {@link IContainer.connectionState}
-     *
-     * - {@link IContainer.disconnect}
-     */
-    (event: "disconnected", listener: () => void): any;
-    /**
-     * Emitted when a {@link AttachState.Detached | detached} container begins the process of
-     * {@link AttachState.Attaching | attached} to the Fluid service.
-     *
-     * @see
-     *
-     * - {@link IContainer.attachState}
-     *
-     * - {@link IContainer.attach}
-     */
-    (event: "attaching", listener: () => void): any;
-    /**
-     * Emitted when the {@link AttachState.Attaching | attaching} process is complete and the container is
-     * {@link AttachState.Attached | attached} to the Fluid service.
-     *
-     * @see
-     *
-     * - {@link IContainer.attachState}
-     *
-     * - {@link IContainer.attach}
-     */
-    (event: "attached", listener: () => void): any;
-    /**
-     * Emitted when the {@link IContainer} is closed, which permanently disables it.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `error`: If the container was closed due to error, this will contain details about the error that caused it.
-     *
-     * @see {@link IContainer.close}
-     */
-    (event: "closed", listener: (error?: ICriticalContainerError) => void): any;
-    /**
-     * Emitted when the {@link IContainer} is disposed, which permanently disables it.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `error`: If the container was disposed due to error, this will contain details about the error that caused it.
-     *
-     * @see {@link IContainer.dispose}
-     */
-    (event: "disposed", listener: (error?: ICriticalContainerError) => void): any;
-    /**
-     * Emitted when the container encounters a state which may lead to errors, which may be actionable by the consumer.
-     *
-     * @remarks
-     *
-     * Note: this event is not intended for general use.
-     * The longer-term intention is to surface warnings more directly on the APIs that produce them.
-     * For now, use of this should be avoided when possible.
-     *
-     * Listener parameters:
-     *
-     * - `error`: The warning describing the encountered state.
-     */
-    (event: "warning", listener: (error: ContainerWarning) => void): any;
-    /**
-     * Emitted immediately after processing an incoming operation (op).
-     *
-     * @remarks
-     *
-     * Note: this event is not intended for general use.
-     * Prefer to listen to events on the appropriate ultimate recipients of the ops, rather than listening to the
-     * ops directly on the {@link IContainer}.
-     *
-     * Listener parameters:
-     *
-     * - `message`: The op that was processed.
-     */
-    (event: "op", listener: (message: ISequencedDocumentMessage) => void): any;
-    /**
-     * Emitted upon the first local change while the Container is in the "saved" state.
-     * That is, when {@link IContainer.isDirty} transitions from `true` to `false`.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `dirty`: DEPRECATED. This parameter will be removed in a future release.
-     *
-     * @see {@link IContainer.isDirty}
-     */
-    (event: "dirty", listener: (dirty: boolean) => void): any;
-    /**
-     * Emitted when all local changes/edits have been acknowledged by the service.
-     * I.e., when {@link IContainer.isDirty} transitions from `false` to `true`.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `dirty`: DEPRECATED. This parameter will be removed in a future release.
-     *
-     * @see {@link IContainer.isDirty}
-     */
-    (event: "saved", listener: (dirty: boolean) => void): any;
-}
+/* Excluded from this release type: IContainerEvents */
 
-/**
- * @public
- */
-export declare interface IContainerLoadMode {
-    opsBeforeReturn?: undefined | "sequenceNumber" | "cached" | "all";
-    deltaConnection?: "none" | "delayed" | undefined;
-    /**
-     * If set to true, will indefinitely pause all incoming and outgoing after the container is loaded.
-     */
-    pauseAfterLoad?: boolean;
-}
+/* Excluded from this release type: IContainerLoadMode */
 
-/**
- * Represents errors raised on container.
- *
- * @see
- *
- * The following are commonly thrown error types, but `errorType` could be any string.
- *
- * - {@link @fluidframework/core-interfaces#ContainerErrorType}
- *
- * - {@link @fluidframework/driver-definitions#DriverErrorType}
- *
- * - {@link @fluidframework/odsp-driver-definitions#OdspErrorType}
- *
- * - {@link @fluidframework/routerlicious-driver#RouterliciousErrorType}
- *
- * @public
- */
-export declare type ICriticalContainerError = IErrorBase;
+/* Excluded from this release type: ICriticalContainerError */
 
-/**
- * Manages the transmission of ops between the runtime and storage.
- * @public
- */
-export declare interface IDeltaManager<T, U> extends IEventProvider<IDeltaManagerEvents>, IDeltaSender {
-    /**
-     * The queue of inbound delta messages
-     */
-    readonly inbound: IDeltaQueue<T>;
-    /**
-     * The queue of outbound delta messages
-     */
-    readonly outbound: IDeltaQueue<U[]>;
-    /**
-     * The queue of inbound delta signals
-     */
-    readonly inboundSignal: IDeltaQueue<ISignalMessage>;
-    /**
-     * The current minimum sequence number
-     */
-    readonly minimumSequenceNumber: number;
-    /**
-     * The last sequence number processed by the delta manager
-     */
-    readonly lastSequenceNumber: number;
-    /**
-     * The last message processed by the delta manager
-     */
-    readonly lastMessage: ISequencedDocumentMessage | undefined;
-    /**
-     * The latest sequence number the delta manager is aware of
-     */
-    readonly lastKnownSeqNumber: number;
-    /**
-     * The initial sequence number set when attaching the op handler
-     */
-    readonly initialSequenceNumber: number;
-    /**
-     * Tells if current connection has checkpoint information.
-     * I.e. we know how far behind the client was at the time of establishing connection
-     */
-    readonly hasCheckpointSequenceNumber: boolean;
-    /**
-     * Details of client
-     */
-    readonly clientDetails: IClientDetails;
-    /**
-     * Protocol version being used to communicate with the service
-     */
-    readonly version: string;
-    /**
-     * Max message size allowed to the delta manager
-     */
-    readonly maxMessageSize: number;
-    /**
-     * Service configuration provided by the service.
-     */
-    readonly serviceConfiguration: IClientConfiguration | undefined;
-    /**
-     * Flag to indicate whether the client can write or not.
-     */
-    readonly active: boolean;
-    readonly readOnlyInfo: ReadOnlyInfo;
-    /**
-     * Submit a signal to the service to be broadcast to other connected clients, but not persisted
-     */
-    submitSignal(content: any, targetClientId?: string): void;
-}
+/* Excluded from this release type: IDeltaManager */
 
-/**
- * Events emitted by {@link IDeltaManager}.
- * @public
- */
-export declare interface IDeltaManagerEvents extends IEvent {
-    /**
-     * @deprecated No replacement API recommended.
-     */
-    (event: "prepareSend", listener: (messageBuffer: any[]) => void): any;
-    /**
-     * @deprecated No replacement API recommended.
-     */
-    (event: "submitOp", listener: (message: IDocumentMessage) => void): any;
-    /**
-     * Emitted immediately after processing an incoming operation (op).
-     *
-     * @remarks
-     *
-     * Note: this event is not intended for general use.
-     * Prefer to listen to events on the appropriate ultimate recipients of the ops, rather than listening to the
-     * ops directly on the {@link IDeltaManager}.
-     *
-     * Listener parameters:
-     *
-     * - `message`: The op that was processed.
-     *
-     * - `processingTime`: The amount of time it took to process the inbound operation (op), expressed in milliseconds.
-     */
-    (event: "op", listener: (message: ISequencedDocumentMessage, processingTime: number) => void): any;
-    /**
-     * Emitted periodically with latest information on network roundtrip latency
-     */
-    (event: "pong", listener: (latency: number) => void): any;
-    /**
-     * Emitted when the {@link IDeltaManager} completes connecting to the Fluid service.
-     *
-     * @remarks
-     * This occurs once we've received the connect_document_success message from the server,
-     * and happens prior to the client's join message (if there is a join message).
-     *
-     * Listener parameters:
-     *
-     * - `details`: Connection metadata.
-     *
-     * - `opsBehind`: An estimate of far behind the client is relative to the service in terms of ops.
-     * Will not be specified if an estimate cannot be determined.
-     */
-    (event: "connect", listener: (details: IConnectionDetails, opsBehind?: number) => void): any;
-    /**
-     * Emitted when the {@link IDeltaManager} becomes disconnected from the Fluid service.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `reason`: Describes the reason for which the delta manager was disconnected.
-     * - `error` : error if any for the disconnect.
-     */
-    (event: "disconnect", listener: (reason: string, error?: IAnyDriverError) => void): any;
-    /**
-     * Emitted when read/write permissions change.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `readonly`: Whether or not the delta manager is now read-only.
-     */
-    (event: "readonly", listener: (readonly: boolean, readonlyConnectionReason?: {
-        reason: string;
-        error?: IErrorBase;
-    }) => void): any;
-}
+/* Excluded from this release type: IDeltaManagerEvents */
 
-/**
- * Queue of ops to be sent to or processed from storage
- * @public
- */
-export declare interface IDeltaQueue<T> extends IEventProvider<IDeltaQueueEvents<T>>, IDisposable {
-    /**
-     * Flag indicating whether or not the queue was paused
-     */
-    paused: boolean;
-    /**
-     * The number of messages remaining in the queue
-     */
-    length: number;
-    /**
-     * Flag indicating whether or not the queue is idle.
-     * I.e. there are no remaining messages to processes.
-     */
-    idle: boolean;
-    /**
-     * Pauses processing on the queue.
-     *
-     * @returns A promise which resolves when processing has been paused.
-     */
-    pause(): Promise<void>;
-    /**
-     * Resumes processing on the queue
-     */
-    resume(): void;
-    /**
-     * Peeks at the next message in the queue
-     */
-    peek(): T | undefined;
-    /**
-     * Returns all the items in the queue as an array. Does not remove them from the queue.
-     */
-    toArray(): T[];
-    /**
-     * returns number of ops processed and time it took to process these ops.
-     * Zeros if queue did not process anything (had no messages, was paused or had hit an error before)
-     */
-    waitTillProcessingDone(): Promise<{
-        count: number;
-        duration: number;
-    }>;
-}
+/* Excluded from this release type: IDeltaQueue */
 
-/**
- * Events emitted by {@link IDeltaQueue}.
- * @public
- */
-export declare interface IDeltaQueueEvents<T> extends IErrorEvent {
-    /**
-     * Emitted when a task is enqueued.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `task`: The task being enqueued.
-     */
-    (event: "push", listener: (task: T) => void): any;
-    /**
-     * Emitted immediately after processing an enqueued task and removing it from the queue.
-     *
-     * @remarks
-     *
-     * Note: this event is not intended for general use.
-     * Prefer to listen to events on the appropriate ultimate recipients of the ops, rather than listening to the
-     * ops directly on the {@link IDeltaQueue}.
-     *
-     * Listener parameters:
-     *
-     * - `task`: The task that was processed.
-     */
-    (event: "op", listener: (task: T) => void): any;
-    /**
-     * Emitted when the queue of tasks to process is emptied.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `count`: The number of events (`T`) processed before becoming idle.
-     *
-     * - `duration`: The amount of time it took to process elements (in milliseconds).
-     *
-     * @see {@link IDeltaQueue.idle}
-     */
-    (event: "idle", listener: (count: number, duration: number) => void): any;
-}
+/* Excluded from this release type: IDeltaQueueEvents */
 
-/**
- * Contract supporting delivery of outbound messages to the server
- * @public
- */
-export declare interface IDeltaSender {
-    /**
-     * Flush all pending messages through the outbound queue
-     */
-    flush(): void;
-}
+/* Excluded from this release type: IDeltaSender */
 
-export { IErrorBase }
+/* Excluded from this release type: IDisposable */
 
-/**
- * A Fluid package for specification for browser environments
- * @public
- */
-export declare interface IFluidBrowserPackage extends IFluidPackage {
-    /**
-     * {@inheritDoc @fluidframework/core-interfaces#IFluidPackage.fluid}
-     */
-    fluid: {
-        /**
-         * The browser specific package information for this package
-         */
-        browser: IFluidBrowserPackageEnvironment;
-        /**
-         * {@inheritDoc @fluidframework/core-interfaces#IFluidPackage.fluid.environment}
-         */
-        [environment: string]: IFluidPackageEnvironment;
-    };
-}
+/* Excluded from this release type: IDocumentStorageService */
 
-/**
- * A specific Fluid package environment for browsers
- * @public
- */
-export declare interface IFluidBrowserPackageEnvironment extends IFluidPackageEnvironment {
-    /**
-     * The Universal Module Definition (umd) target specifics the scripts necessary for
-     * loading a packages in a browser environment and finding its entry point.
-     */
-    umd: {
-        /**
-         * The bundled js files for loading this package.
-         * These files will be loaded and executed in order.
-         */
-        files: string[];
-        /**
-         * The global name that the script entry points will be exposed.
-         * This entry point should be an {@link @fluidframework/container-definitions#IFluidModule}.
-         */
-        library: string;
-    };
-}
+/* Excluded from this release type: IErrorBase */
 
-/**
- * Data structure used to describe the code to load on the Fluid document
- * @public
- */
-export declare interface IFluidCodeDetails {
-    /**
-     * The code package to be used on the Fluid document. This is either the package name which will be loaded
-     * from a package manager. Or the expanded Fluid package.
-     */
-    readonly package: string | Readonly<IFluidPackage>;
-    /**
-     * Configuration details. This includes links to the package manager and base CDNs.
-     *
-     * @remarks This is strictly consumer-defined data.
-     * Its contents and semantics (including whether or not this data is present) are completely up to the consumer.
-     */
-    readonly config?: IFluidCodeDetailsConfig;
-}
+/* Excluded from this release type: IErrorEvent */
 
-/**
- * @public
- */
-export declare const IFluidCodeDetailsComparer: keyof IProvideFluidCodeDetailsComparer;
+/* Excluded from this release type: IEvent */
 
-/**
- * Provides capability to compare Fluid code details.
- * @public
- */
-export declare interface IFluidCodeDetailsComparer extends IProvideFluidCodeDetailsComparer {
-    /**
-     * Determines if the `candidate` code details satisfy the constraints specified in `constraint` code details.
-     *
-     * Similar semantics to:
-     * {@link https://github.com/npm/node-semver#usage}
-     */
-    satisfies(candidate: IFluidCodeDetails, constraint: IFluidCodeDetails): Promise<boolean>;
-    /**
-     * Return a number representing the ascending sort order of the `a` and `b` code details:
-     *
-     * - `< 0` if `a < b`.
-     *
-     * - `= 0` if `a === b`.
-     *
-     * - `> 0` if `a > b`.
-     *
-     * - `undefined` if `a` is not comparable to `b`.
-     *
-     * Similar semantics to:
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description | Array.sort}
-     */
-    compare(a: IFluidCodeDetails, b: IFluidCodeDetails): Promise<number | undefined>;
-}
+/* Excluded from this release type: IEventProvider */
 
-/**
- * Package manager configuration. Provides a key value mapping of config values
- * @public
- */
-export declare interface IFluidCodeDetailsConfig {
-    readonly [key: string]: string;
-}
+/* Excluded from this release type: IFluidBrowserPackage */
 
-/**
- * Fluid code resolvers take a Fluid code details, and resolve the
- * full Fluid package including absolute urls for the browser file entries.
- * The Fluid code resolver is coupled to a specific cdn and knows how to resolve
- * the code detail for loading from that cdn. This include resolving to the most recent
- * version of package that supports the provided code details.
- * @public
- */
-export declare interface IFluidCodeResolver {
-    /**
-     * Resolves a Fluid code details into a form that can be loaded.
-     * @param details - The Fluid code details to resolve.
-     * @returns A IResolvedFluidCodeDetails where the resolvedPackage's Fluid file entries are absolute urls, and
-     * an optional resolvedPackageCacheId if the loaded package should be cached.
-     */
-    resolveCodeDetails(details: IFluidCodeDetails): Promise<IResolvedFluidCodeDetails>;
-}
+/* Excluded from this release type: IFluidBrowserPackageEnvironment */
 
-/**
- * @public
- */
-export declare interface IFluidModule {
-    fluidExport: FluidObject<IRuntimeFactory & IProvideFluidCodeDetailsComparer>;
-}
+/* Excluded from this release type: IFluidCodeDetails */
 
-/**
- * Encapsulates a module entry point with corresponding code details.
- * @public
- */
-export declare interface IFluidModuleWithDetails {
-    /**
-     * Fluid code module that implements the runtime factory needed to instantiate the container runtime.
-     */
-    module: IFluidModule;
-    /**
-     * Code details associated with the module. Represents a document schema this module supports.
-     * If the code loader implements the {@link @fluidframework/core-interfaces#(IFluidCodeDetailsComparer:interface)}
-     * interface, it'll be called to determine whether the module code details satisfy the new code proposal in the
-     * quorum.
-     */
-    details: IFluidCodeDetails;
-}
+/* Excluded from this release type: IFluidCodeDetailsComparer */
 
-/**
- * Fluid-specific properties expected on a package to be loaded by the code loader.
- * While compatible with the npm package format it is not necessary that that package is an
- * npm package:
- * {@link https://stackoverflow.com/questions/10065564/add-custom-metadata-or-config-to-package-json-is-it-valid}
- * @public
- */
-export declare interface IFluidPackage {
-    /**
-     * The name of the package that this code represnets
-     */
-    name: string;
-    /**
-     * This object represents the Fluid specific properties of the package
-     */
-    fluid: {
-        /**
-         * The name of the of the environment. This should be something like browser, or node
-         * and contain the necessary targets for loading this code in that environment.
-         */
-        [environment: string]: undefined | IFluidPackageEnvironment;
-    };
-    /**
-     * General access for extended fields as specific usages will
-     * likely have additional infornamation like a definition of
-     * compatible versions, or deployment information like rings or rollouts.
-     */
-    [key: string]: unknown;
-}
+/* Excluded from this release type: IFluidCodeDetailsConfig */
 
-/**
- * Specifies an environment on Fluid property of a IFluidPackage.
- * @public
- */
-export declare interface IFluidPackageEnvironment {
-    /**
-     * The name of the target. For a browser environment, this could be umd for scripts
-     * or css for styles.
-     */
-    [target: string]: undefined | {
-        /**
-         * List of files for the target. These can be relative or absolute.
-         * The code loader should resolve relative paths, and validate all
-         * full urls.
-         */
-        files: string[];
-        /**
-         * General access for extended fields as specific usages will
-         * likely have additional infornamation like a definition
-         * of Library, the entrypoint for umd packages.
-         */
-        [key: string]: unknown;
-    };
-}
-
-export { IGenericError }
+/* Excluded from this release type: IFluidCodeResolver */
 
-/**
- * Defines list of properties expected for getPendingLocalState
- * @alpha
- */
-export declare interface IGetPendingLocalStateProps {
-    /**
-     * Indicates the container will close after getting the pending state. Used internally
-     * to wait for blobs to be attached to a DDS and collect generated ops before closing.
-     */
-    readonly notifyImminentClosure: boolean;
-    /**
-     * Abort signal to stop waiting for blobs to get attached to a DDS. When triggered,
-     * only blobs attached will be collected in the pending state.
-     * Intended to be used in the very rare scenario in which getLocalPendingState go stale due
-     * to a blob failed to be referenced. Such a blob will be lost but the rest of the state will
-     * be preserved and collected.
-     */
-    readonly stopBlobAttachingSignal?: AbortSignal;
-}
+/* Excluded from this release type: IFluidModule */
 
-/**
- * The Host's view of the Loader, used for loading Containers
- * @public
- */
-export declare interface IHostLoader extends ILoader {
-    /**
-     * Creates a new container using the specified chaincode but in an unattached state. While unattached all
-     * updates will only be local until the user explicitly attaches the container to a service provider.
-     */
-    createDetachedContainer(codeDetails: IFluidCodeDetails, createDetachedProps?: {
-        canReconnect?: boolean;
-        clientDetailsOverride?: IClientDetails;
-    }): Promise<IContainer>;
-    /**
-     * Creates a new container using the specified snapshot but in an unattached state. While unattached all
-     * updates will only be local until the user explicitly attaches the container to a service provider.
-     */
-    rehydrateDetachedContainerFromSnapshot(snapshot: string, createDetachedProps?: {
-        canReconnect?: boolean;
-        clientDetailsOverride?: IClientDetails;
-    }): Promise<IContainer>;
-}
+/* Excluded from this release type: IFluidModuleWithDetails */
 
-/**
- * The Runtime's view of the Loader, used for loading Containers
- * @public
- */
-export declare interface ILoader extends Partial<IProvideLoader> {
-    /**
-     * Resolves the resource specified by the URL + headers contained in the request object
-     * to the underlying container that will resolve the request.
-     *
-     * @remarks
-     *
-     * An analogy for this is resolve is a DNS resolve of a Fluid container. Request then executes
-     * a request against the server found from the resolve step.
-     */
-    resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer>;
-    /**
-     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
-     */
-    request(request: IRequest): Promise<IResponse>;
-    /**
-     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
-     */
-    readonly IFluidRouter: IFluidRouter;
-}
+/* Excluded from this release type: IFluidPackage */
 
-/**
- * Set of Request Headers that the Loader understands and may inspect or modify
- * @public
- */
-export declare interface ILoaderHeader {
-    /**
-     * @deprecated This header has been deprecated and will be removed in a future release
-     */
-    [LoaderHeader.cache]: boolean;
-    [LoaderHeader.clientDetails]: IClientDetails;
-    [LoaderHeader.loadMode]: IContainerLoadMode;
-    /**
-     * Loads the container to at least the specified sequence number.
-     * If not defined, behavior will fall back to `IContainerLoadMode.opsBeforeReturn`.
-     */
-    [LoaderHeader.sequenceNumber]: number;
-    [LoaderHeader.reconnect]: boolean;
-    [LoaderHeader.version]: string | undefined;
-}
+/* Excluded from this release type: IFluidPackageEnvironment */
 
-/**
- * @public
- */
-export declare type ILoaderOptions = {
-    [key in string | number]: any;
-} & {
-    /**
-     * @deprecated This option has been deprecated and will be removed in a future release
-     * Set caching behavior for the loader. If true, we will load a container from cache if one
-     * with the same id/version exists or create a new container and cache it if it does not. If
-     * false, always load a new container and don't cache it. If the container has already been
-     * closed, it will not be cached. A cache option in the LoaderHeader for an individual
-     * request will override the Loader's value.
-     * Defaults to false.
-     */
-    cache?: boolean;
-    /**
-     * Provide the current Loader through the scope object when creating Containers. It is added
-     * as the `ILoader` property, and will overwrite an existing property of the same name on the
-     * scope. Useful for when the host wants to provide the current Loader's functionality to
-     * individual Data Stores, which is typically expected when creating with a Loader.
-     * Defaults to true.
-     */
-    provideScopeLoader?: boolean;
-    /**
-     * Max time (in ms) container will wait for a leave message of a disconnected client.
-     */
-    maxClientLeaveWaitTime?: number;
-};
+/* Excluded from this release type: IFluidRouter */
 
-/**
- * @deprecated 0.48, This API will be removed in 0.50
- * No replacement since it is not expected anyone will depend on this outside container-loader
- * See {@link https://github.com/microsoft/FluidFramework/issues/9711} for context.
- * @public
- */
-export declare interface IPendingLocalState {
-    url: string;
-    pendingRuntimeState: unknown;
-}
+/* Excluded from this release type: IGenericError */
 
-/**
- * @public
- */
-export declare interface IProvideFluidCodeDetailsComparer {
-    readonly IFluidCodeDetailsComparer: IFluidCodeDetailsComparer;
-}
+/* Excluded from this release type: IGetPendingLocalStateProps */
 
-/**
- * @public
- */
-export declare interface IProvideLoader {
-    readonly ILoader: ILoader;
-}
+/* Excluded from this release type: IHostLoader */
 
-/**
- * @public
- */
-export declare interface IProvideRuntimeFactory {
-    readonly IRuntimeFactory: IRuntimeFactory;
-}
+/* Excluded from this release type: ILoader */
 
-/**
- * The interface returned from a IFluidCodeResolver which represents IFluidCodeDetails
- * that have been resolved and are ready to load
- * @public
- */
-export declare interface IResolvedFluidCodeDetails extends IFluidCodeDetails {
-    /**
-     * A resolved version of the Fluid package. All Fluid browser file entries should be absolute urls.
-     */
-    readonly resolvedPackage: Readonly<IFluidPackage>;
-    /**
-     * If not undefined, this id will be used to cache the entry point for the code package
-     */
-    readonly resolvedPackageCacheId: string | undefined;
-}
+/* Excluded from this release type: ILoaderHeader */
 
-/**
- * The IRuntime represents an instantiation of a code package within a Container.
- * Primarily held by the ContainerContext to be able to interact with the running instance of the Container.
- * @public
- */
-export declare interface IRuntime extends IDisposable {
-    /**
-     * Executes a request against the runtime
-     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
-     */
-    request(request: IRequest): Promise<IResponse>;
-    /**
-     * Notifies the runtime of a change in the connection state
-     */
-    setConnectionState(connected: boolean, clientId?: string): any;
-    /**
-     * Processes the given op (message)
-     */
-    process(message: ISequencedDocumentMessage, local: boolean): any;
-    /**
-     * Processes the given signal
-     */
-    processSignal(message: any, local: boolean): any;
-    /**
-     * Create a summary. Used when attaching or serializing a detached container.
-     *
-     * @param blobRedirectTable - A table passed during the attach process. While detached, blob upload is supported
-     * using IDs generated locally. After attach, these IDs cannot be used, so this table maps the old local IDs to the
-     * new storage IDs so requests can be redirected.
-     */
-    createSummary(blobRedirectTable?: Map<string, string>): ISummaryTree;
-    /**
-     * Propagate the container state when container is attaching or attached.
-     * @param attachState - State of the container.
-     */
-    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
-    /**
-     * Get pending local state in a serializable format to be given back to a newly loaded container
-     * @alpha
-     * {@link https://github.com/microsoft/FluidFramework/packages/tree/main/loader/container-loader/closeAndGetPendingLocalState.md}
-     */
-    getPendingLocalState(props?: IGetPendingLocalStateProps): unknown;
-    /**
-     * Notify runtime that container is moving to "Attaching" state
-     * @param snapshot - snapshot created at attach time
-     * @deprecated not necessary after op replay moved to Container
-     */
-    notifyAttaching(snapshot: ISnapshotTreeWithBlobContents): void;
-    /**
-     * Notify runtime that we have processed a saved message, so that it can do async work (applying
-     * stashed ops) after having processed it.
-     */
-    notifyOpReplay?(message: ISequencedDocumentMessage): Promise<void>;
-    /**
-     * Exposes the entryPoint for the container runtime.
-     * Use this as the primary way of getting access to the user-defined logic within the container runtime.
-     *
-     * @see {@link IContainer.getEntryPoint}
-     */
-    getEntryPoint(): Promise<FluidObject | undefined>;
-}
+/* Excluded from this release type: ILoaderOptions */
 
-/**
- * @public
- */
-export declare const IRuntimeFactory: keyof IProvideRuntimeFactory;
+/* Excluded from this release type: IPendingLocalState */
 
-/**
- * Exported module definition
- *
- * Provides the entry point for the ContainerContext to load the proper IRuntime
- * to start up the running instance of the Container.
- * @public
- */
-export declare interface IRuntimeFactory extends IProvideRuntimeFactory {
-    /**
-     * Instantiates a new IRuntime for the given IContainerContext to proxy to
-     * This is the main entry point to the Container's business logic
-     *
-     * @param context - container context to be supplied to the runtime
-     * @param existing - whether to instantiate for the first time or from an existing context
-     */
-    instantiateRuntime(context: IContainerContext, existing: boolean): Promise<IRuntime>;
-}
+/* Excluded from this release type: IProvideFluidCodeDetailsComparer */
 
-/**
- * Determines if any object is an IFluidBrowserPackage
- * @param maybePkg - The object to check for compatibility with IFluidBrowserPackage
- * @public
- */
-export declare const isFluidBrowserPackage: (maybePkg: unknown) => maybePkg is Readonly<IFluidBrowserPackage>;
+/* Excluded from this release type: IProvideLoader */
 
-/**
- * Determines if any object is an IFluidCodeDetails
- * @public
- */
-export declare const isFluidCodeDetails: (details: unknown) => details is Readonly<IFluidCodeDetails>;
+/* Excluded from this release type: IProvideRuntimeFactory */
 
-/**
- * Check if the package.json defines a Fluid package
- * @param pkg - the package json data to check if it is a Fluid package.
- * @public
- */
-export declare const isFluidPackage: (pkg: unknown) => pkg is Readonly<IFluidPackage>;
+/* Excluded from this release type: IRequest */
 
-/**
- * This is used when we rehydrate a container from the snapshot. Here we put the blob contents
- * in separate property: {@link ISnapshotTreeWithBlobContents.blobsContents}.
- *
- * @remarks This is used as the `ContainerContext`'s base snapshot when attaching.
- * @public
- */
-export declare interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
-    blobsContents: {
-        [path: string]: ArrayBufferLike;
-    };
-    trees: {
-        [path: string]: ISnapshotTreeWithBlobContents;
-    };
-}
+/* Excluded from this release type: IResolvedFluidCodeDetails */
 
-export { IThrottlingWarning }
+/* Excluded from this release type: IResolvedUrl */
 
-export { IUsageError }
+/* Excluded from this release type: IResponse */
 
-/**
- * Accepted header keys for requests coming to the Loader
- * @public
- */
-export declare enum LoaderHeader {
-    /**
-     * @deprecated This header has been deprecated and will be removed in a future release
-     * Override the Loader's default caching behavior for this container.
-     */
-    cache = "fluid-cache",
-    clientDetails = "fluid-client-details",
-    /**
-     * Start the container in a paused, unconnected state. Defaults to false
-     */
-    loadMode = "loadMode",
-    reconnect = "fluid-reconnect",
-    /**
-     * Loads the container to at least the specified sequence number.
-     * If not defined, behavior will fall back to `IContainerLoadMode.opsBeforeReturn`.
-     */
-    sequenceNumber = "fluid-sequence-number",
-    /**
-     * One of the following:
-     * null or "null": use ops, no snapshots
-     * undefined: fetch latest snapshot
-     * otherwise, version sha to load snapshot
-     */
-    version = "version"
-}
+/* Excluded from this release type: IRuntime */
 
-/**
- * @public
- */
-export declare type ReadOnlyInfo = {
-    readonly readonly: false | undefined;
-} | {
-    readonly readonly: true;
-    /**
-     * Read-only because `forceReadOnly()` was called.
-     */
-    readonly forced: boolean;
-    /**
-     * Read-only because client does not have write permissions for document.
-     */
-    readonly permissions: boolean | undefined;
-    /**
-     * Read-only with no delta stream connection.
-     */
-    readonly storageOnly: boolean;
-    /**
-     * Extra info on why connection to delta stream is not possible.
-     *
-     * @remarks This info might be provided if {@link ReadOnlyInfo.storageOnly} is set to `true`.
-     */
-    readonly storageOnlyReason?: string;
-};
+/* Excluded from this release type: IRuntimeFactory */
+
+/* Excluded from this release type: isFluidBrowserPackage */
+
+/* Excluded from this release type: isFluidCodeDetails */
+
+/* Excluded from this release type: isFluidPackage */
+
+/* Excluded from this release type: ISnapshotTreeWithBlobContents */
+
+/* Excluded from this release type: ITelemetryBaseLogger */
+
+/* Excluded from this release type: IThrottlingWarning */
+
+/* Excluded from this release type: IUsageError */
+
+/* Excluded from this release type: LoaderHeader */
+
+/* Excluded from this release type: ReadOnlyInfo */
 
 export { }