@fluidframework/driver-definitions 2.0.0-dev.7.3.0.210328 → 2.0.0-dev.7.3.0.211848

package/api-extractor.json

@@ -8,5 +8,8 @@
 				"logLevel": "none"
 			}
 		}
+	},
+	"dtsRollup": {
+		"enabled": true
 	}
 }

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

@@ -0,0 +1,638 @@
+import { ConnectionMode } from '@fluidframework/protocol-definitions';
+import { IClient } from '@fluidframework/protocol-definitions';
+import { IClientConfiguration } from '@fluidframework/protocol-definitions';
+import { ICreateBlobResponse } from '@fluidframework/protocol-definitions';
+import { IDisposable } from '@fluidframework/core-interfaces';
+import { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import { IErrorEvent } from '@fluidframework/core-interfaces';
+import { IEventProvider } from '@fluidframework/core-interfaces';
+import { INack } from '@fluidframework/protocol-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISignalClient } from '@fluidframework/protocol-definitions';
+import { ISignalMessage } from '@fluidframework/protocol-definitions';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { ISummaryHandle } from '@fluidframework/protocol-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { ITokenClaims } from '@fluidframework/protocol-definitions';
+import { IVersion } from '@fluidframework/protocol-definitions';
+
+export declare type DriverError = IThrottlingWarning | IGenericNetworkError | IAuthorizationError | ILocationRedirectionError | IDriverBasicError;
+
+/**
+ * Driver Error types
+ * Lists types that are likely to be used by all drivers
+ *
+ * @deprecated Use {@link (DriverErrorTypes:type)} instead.
+ */
+export declare enum DriverErrorType {
+    /**
+     * A fatal error with no specific interpretation covered by other DriverErrorType values
+     */
+    genericError = "genericError",
+    /**
+     * Some non-categorized (below) networking error
+     * Include errors like  fatal server error (usually 500).
+     */
+    genericNetworkError = "genericNetworkError",
+    /**
+     * Access denied - user does not have enough privileges to open a file, or continue to operate on a file
+     */
+    authorizationError = "authorizationError",
+    /**
+     * File not found, or file deleted during session
+     */
+    fileNotFoundOrAccessDeniedError = "fileNotFoundOrAccessDeniedError",
+    /**
+     * Throttling error from server. Server is busy and is asking not to reconnect for some time
+     */
+    throttlingError = "throttlingError",
+    /**
+     * We can not reach server due to computer being offline.
+     */
+    offlineError = "offlineError",
+    unsupportedClientProtocolVersion = "unsupportedClientProtocolVersion",
+    /**
+     * User does not have write permissions to a file, but is changing content of a file.
+     * That might be indication of some data store error - data stores should not generate ops in readonly mode.
+     */
+    writeError = "writeError",
+    /**
+     * A generic fetch failure that indicates we were not able to get a response from the server.
+     * This may be due to the client being offline (though, if we are able to detect offline state it will be
+     * logged as an offlineError instead).  Other possibilities could be DNS errors, malformed fetch request,
+     * CSP violation, etc.
+     */
+    fetchFailure = "fetchFailure",
+    /**
+     * This error occurs when token provider fails to fetch orderer token
+     */
+    fetchTokenError = "fetchTokenError",
+    /**
+     * Unexpected response from server. Either JSON is malformed, or some required properties are missing
+     */
+    incorrectServerResponse = "incorrectServerResponse",
+    /**
+     * This error occurs when the file is modified externally (not through Fluid protocol) in storage.
+     * It will occur in cases where client has some state or cache that is based on old content (identity) of a file,
+     * and storage / driver / loader detects such mismatch.
+     * When it's hit, client needs to forget all the knowledge about this file and start over.
+     */
+    fileOverwrittenInStorage = "fileOverwrittenInStorage",
+    /**
+     * The document is read-only and delta stream connection is forbidden.
+     */
+    deltaStreamConnectionForbidden = "deltaStreamConnectionForbidden",
+    /**
+     * The location of file/container can change on server. So if the file location moves and we try to access the old
+     * location, then this error is thrown to let the client know about the new location info.
+     */
+    locationRedirection = "locationRedirection",
+    /**
+     * When a file is not a Fluid file, but has Fluid extension such as ".note",
+     * server won't be able to open it and will return this error. The innerMostErrorCode will be
+     * "fluidInvalidSchema"
+     */
+    fluidInvalidSchema = "fluidInvalidSchema",
+    /**
+     * Error indicating an API is being used improperly resulting in an invalid operation.
+     * ! Should match the value of ContainerErrorType.usageError
+     */
+    usageError = "usageError",
+    /**
+     * File is locked for read/write by storage, e.g. whole collection is locked and access denied.
+     */
+    fileIsLocked = "fileIsLocked",
+    /**
+     * Storage is out of space
+     */
+    outOfStorageError = "outOfStorageError"
+}
+
+/**
+ * Different error types the Driver may report out to the Host.
+ */
+export declare const DriverErrorTypes: {
+    /**
+     * Some non-categorized (below) networking error
+     * Include errors like  fatal server error (usually 500).
+     */
+    readonly genericNetworkError: "genericNetworkError";
+    /**
+     * Access denied - user does not have enough privileges to open a file, or continue to operate on a file
+     */
+    readonly authorizationError: "authorizationError";
+    /**
+     * File not found, or file deleted during session
+     */
+    readonly fileNotFoundOrAccessDeniedError: "fileNotFoundOrAccessDeniedError";
+    /**
+     * We can not reach server due to computer being offline.
+     */
+    readonly offlineError: "offlineError";
+    readonly unsupportedClientProtocolVersion: "unsupportedClientProtocolVersion";
+    /**
+     * User does not have write permissions to a file, but is changing content of a file.
+     * That might be indication of some data store error - data stores should not generate ops in readonly mode.
+     */
+    readonly writeError: "writeError";
+    /**
+     * A generic fetch failure that indicates we were not able to get a response from the server.
+     * This may be due to the client being offline (though, if we are able to detect offline state it will be
+     * logged as an offlineError instead).  Other possibilities could be DNS errors, malformed fetch request,
+     * CSP violation, etc.
+     */
+    readonly fetchFailure: "fetchFailure";
+    /**
+     * This error occurs when token provider fails to fetch orderer token
+     */
+    readonly fetchTokenError: "fetchTokenError";
+    /**
+     * Unexpected response from server. Either JSON is malformed, or some required properties are missing
+     */
+    readonly incorrectServerResponse: "incorrectServerResponse";
+    /**
+     * This error occurs when the file is modified externally (not through Fluid protocol) in storage.
+     * It will occur in cases where client has some state or cache that is based on old content (identity) of a file,
+     * and storage / driver / loader detects such mismatch.
+     * When it's hit, client needs to forget all the knowledge about this file and start over.
+     */
+    readonly fileOverwrittenInStorage: "fileOverwrittenInStorage";
+    /**
+     * The document is read-only and delta stream connection is forbidden.
+     */
+    readonly deltaStreamConnectionForbidden: "deltaStreamConnectionForbidden";
+    /**
+     * The location of file/container can change on server. So if the file location moves and we try to access the old
+     * location, then this error is thrown to let the client know about the new location info.
+     */
+    readonly locationRedirection: "locationRedirection";
+    /**
+     * When a file is not a Fluid file, but has Fluid extension such as ".note",
+     * server won't be able to open it and will return this error. The innerMostErrorCode will be
+     * "fluidInvalidSchema"
+     */
+    readonly fluidInvalidSchema: "fluidInvalidSchema";
+    /**
+     * File is locked for read/write by storage, e.g. whole collection is locked and access denied.
+     */
+    readonly fileIsLocked: "fileIsLocked";
+    /**
+     * Storage is out of space
+     */
+    readonly outOfStorageError: "outOfStorageError";
+    readonly genericError: "genericError";
+    readonly throttlingError: "throttlingError";
+    readonly usageError: "usageError";
+};
+
+export declare type DriverErrorTypes = (typeof DriverErrorTypes)[keyof typeof DriverErrorTypes];
+
+/**
+ * Additional key in the loader request header
+ */
+export declare enum DriverHeader {
+    summarizingClient = "fluid-client-summarizer",
+    createNew = "createNew"
+}
+
+/**
+ * Information that can be returned by a lightweight, seperately exported driver function. Used to preanalyze a URL
+ * for driver compatibility and preload information.
+ */
+export declare interface DriverPreCheckInfo {
+    /**
+     * A code details hint that can potentially be used to prefetch container code prior to having a snapshot.
+     */
+    codeDetailsHint?: string;
+    /**
+     * Domains that will be connected to on the critical boot path. Hosts can choose to preconnect to these for
+     * improved performance.
+     */
+    criticalBootDomains?: string[];
+}
+
+export declare enum FetchSource {
+    default = "default",
+    noCache = "noCache"
+}
+
+export declare type FiveDaysMs = 432000000;
+
+/**
+ * Interface describing errors and warnings raised by any driver code.
+ * Not expected to be implemented by a class or an object literal, but rather used in place of
+ * any or unknown in various function signatures that pass errors around.
+ *
+ * "Any" in the interface name is a nod to the fact that errorType has lost its type constraint.
+ * It will be either DriverErrorType or the specific driver's specialized error type enum,
+ * but we can't reference a specific driver's error type enum in this code.
+ */
+export declare interface IAnyDriverError extends Omit<IDriverErrorBase, "errorType"> {
+    readonly errorType: string;
+}
+
+export declare interface IAuthorizationError extends IDriverErrorBase {
+    readonly errorType: DriverErrorType.authorizationError;
+    readonly claims?: string;
+    readonly tenantId?: string;
+}
+
+/**
+ * Container package info handed off to resolver.
+ */
+export declare interface IContainerPackageInfo {
+    /**
+     * Container package name.
+     */
+    name: string;
+}
+
+export declare interface IDeltasFetchResult {
+    /**
+     * Sequential set of messages starting from 'from' sequence number.
+     * May be partial result, i.e. not fulfill original request in full.
+     */
+    messages: ISequencedDocumentMessage[];
+    /**
+     * If true, storage only partially fulfilled request, but has more ops
+     * If false, the request was fulfilled. If less ops were returned then
+     * requested, then storage does not have more ops in this range.
+     */
+    partialResult: boolean;
+}
+
+/**
+ * Interface to provide access to stored deltas for a shared object
+ */
+export declare interface IDeltaStorageService {
+    /**
+     * Retrieves all the delta operations within the inclusive sequence number range
+     * @param tenantId - Id of the tenant.
+     * @param id - document id.
+     * @param from - first op to retrieve (inclusive)
+     * @param to - first op not to retrieve (exclusive end)
+     * @param fetchReason - Reason for fetching the messages, for logging.
+     * Example, gap between seq number of Op on wire and known seq number.
+     * It can be logged by spo which could help in debugging sessions if any issue occurs.
+     */
+    get(tenantId: string, id: string, from: number, // inclusive
+    to: number, // exclusive
+    fetchReason?: string): Promise<IDeltasFetchResult>;
+}
+
+export declare interface IDocumentDeltaConnection extends IDisposable, IEventProvider<IDocumentDeltaConnectionEvents> {
+    /**
+     * ClientID for the connection
+     */
+    clientId: string;
+    /**
+     * Claims for the client
+     */
+    claims: ITokenClaims;
+    /**
+     * Mode of the client
+     */
+    mode: ConnectionMode;
+    /**
+     * Whether the connection was made to a new or existing document
+     */
+    existing: boolean;
+    /**
+     * Protocol version being used with the service
+     */
+    version: string;
+    /**
+     * Messages sent during the connection
+     */
+    initialMessages: ISequencedDocumentMessage[];
+    /**
+     * Signals sent during the connection
+     */
+    initialSignals: ISignalMessage[];
+    /**
+     * Prior clients already connected.
+     */
+    initialClients: ISignalClient[];
+    /**
+     * Configuration details provided by the service
+     */
+    serviceConfiguration: IClientConfiguration;
+    /**
+     * Last known sequence number to ordering service at the time of connection
+     * It may lap actual last sequence number (quite a bit, if container  is very active).
+     * But it's 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;
+    /**
+     * Properties that server can send to client to tell info about node that client is connected to. For ex, for spo
+     * it could contain info like build version, environment, region etc. These properties can be logged by client
+     * to better understand server environment etc. and use it in case error occurs.
+     * Format: "prop1:val1;prop2:val2;prop3:val3"
+     */
+    relayServiceAgent?: string;
+    /**
+     * Submit a new message to the server
+     */
+    submit(messages: IDocumentMessage[]): void;
+    /**
+     * Submits a new signal to the server
+     */
+    submitSignal(content: any, targetClientId?: string): void;
+}
+
+export declare interface IDocumentDeltaConnectionEvents extends IErrorEvent {
+    (event: "nack", listener: (documentId: string, message: INack[]) => void): any;
+    (event: "disconnect", listener: (reason: IAnyDriverError) => void): any;
+    (event: "op", listener: (documentId: string, messages: ISequencedDocumentMessage[]) => void): any;
+    (event: "signal", listener: (message: ISignalMessage | ISignalMessage[]) => void): any;
+    (event: "pong", listener: (latency: number) => void): any;
+    (event: "error", listener: (error: any) => void): any;
+}
+
+/**
+ * Interface to provide access to stored deltas for a shared object
+ */
+export declare interface IDocumentDeltaStorageService {
+    /**
+     * Retrieves all the delta operations within the exclusive sequence number range
+     * @param from - first op to retrieve (inclusive)
+     * @param to - first op not to retrieve (exclusive end)
+     * @param abortSignal - signal that aborts operation
+     * @param cachedOnly - return only cached ops, i.e. ops available locally on client.
+     * @param fetchReason - Reason for fetching the messages, for logging.
+     * Example, gap between seq number of Op on wire and known seq number.
+     * It can be logged by spo which could help in debugging sessions if any issue occurs.
+     */
+    fetchMessages(from: number, to: number | undefined, abortSignal?: AbortSignal, cachedOnly?: boolean, fetchReason?: string): IStream<ISequencedDocumentMessage[]>;
+}
+
+export declare interface IDocumentService {
+    resolvedUrl: IResolvedUrl;
+    /**
+     * Policies implemented/instructed by driver.
+     */
+    policies?: IDocumentServicePolicies;
+    /**
+     * Access to storage associated with the document
+     */
+    connectToStorage(): Promise<IDocumentStorageService>;
+    /**
+     * Access to delta storage associated with the document
+     */
+    connectToDeltaStorage(): Promise<IDocumentDeltaStorageService>;
+    /**
+     * Subscribes to the document delta stream
+     */
+    connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection>;
+    /**
+     * Dispose storage. Called by storage consumer (Container) when it's done with storage (Container closed).
+     * Useful for storage to commit any pending state if any (including any local caching).
+     * Please note that it does not remove the need for caller to close all active delta connections,
+     * as storage may not be tracking such objects.
+     * @param error - tells if container (and storage) are closed due to critical error.
+     * Error might be due to disconnect between client & server knowledge about file, like file being overwritten
+     * in storage, but client having stale local cache.
+     * If driver implements any kind of local caching, such caches needs to be cleared on on critical errors.
+     */
+    dispose(error?: any): void;
+}
+
+export declare interface IDocumentServiceFactory {
+    /**
+     * Creates the document service after extracting different endpoints URLs from a resolved URL.
+     *
+     * @param resolvedUrl - Endpoint URL data. See {@link IResolvedUrl}.
+     * @param logger - Optional telemetry logger to which telemetry events will be forwarded.
+     * @param clientIsSummarizer - Whether or not the client is the
+     * {@link https://fluidframework.com/docs/concepts/summarizer/ | summarizer}.
+     * `undefined` =\> false
+     *
+     * @returns An instance of {@link IDocumentService}.
+     */
+    createDocumentService(resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+    /**
+     * Creates a new document with the provided options. Returns the document service.
+     *
+     * @param createNewSummary - Summary used to create file. If undefined, an empty file will be created and a summary
+     * should be posted later, before connecting to ordering service.
+     * @param createNewResolvedUrl - Endpoint URL data. See {@link IResolvedUrl}.
+     * @param logger - Optional telemetry logger to which telemetry events will be forwarded.
+     * @param clientIsSummarizer - Whether or not the client is the
+     * {@link https://fluidframework.com/docs/concepts/summarizer/ | summarizer}.
+     * `undefined` =\> false
+     */
+    createContainer(createNewSummary: ISummaryTree | undefined, createNewResolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+}
+
+export declare interface IDocumentServicePolicies {
+    /**
+     * Do not connect to delta stream
+     */
+    readonly storageOnly?: boolean;
+    /**
+     * Summarizer uploads the protocol tree too when summarizing.
+     */
+    readonly summarizeProtocolTree?: boolean;
+}
+
+/**
+ * Interface to provide access to snapshots saved for a shared object
+ */
+export declare interface IDocumentStorageService extends Partial<IDisposable> {
+    repositoryUrl: string;
+    /**
+     * Policies implemented/instructed by driver.
+     */
+    readonly policies?: IDocumentStorageServicePolicies;
+    /**
+     * Returns the snapshot tree.
+     * @param version - Version of the snapshot to be fetched.
+     * @param scenarioName - scenario in which this api is called. This will be recorded by server and would help
+     * in debugging purposes to see why this call was made.
+     */
+    getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null>;
+    /**
+     * Retrieves all versions of the document starting at the specified versionId - or null if from the head
+     * @param versionId - Version id of the requested version.
+     * @param count - Number of the versions to be fetched.
+     * @param scenarioName - scenario in which this api is called. This will be recorded by server and would help
+     * in debugging purposes to see why this call was made.
+     * @param fetchSource - Callers can specify the source of the response. For ex. Driver may choose to cache
+     * requests and serve data from cache. That will result in stale info returned. Callers can disable this
+     * functionality by passing fetchSource = noCache and ensuring that driver will return latest information
+     * from storage.
+     */
+    getVersions(versionId: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<IVersion[]>;
+    /**
+     * Creates a blob out of the given buffer
+     */
+    createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse>;
+    /**
+     * Reads the object with the given ID, returns content in arrayBufferLike
+     */
+    readBlob(id: string): Promise<ArrayBufferLike>;
+    /**
+     * Uploads a summary tree to storage using the given context for reference of previous summary handle.
+     * The ISummaryHandles in the uploaded tree should have paths to indicate which summary object they are
+     * referencing from the previously acked summary.
+     * Returns the uploaded summary handle.
+     */
+    uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string>;
+    /**
+     * Retrieves the commit that matches the packfile handle. If the packfile has already been committed and the
+     * server has deleted it this call may result in a broken promise.
+     */
+    downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree>;
+}
+
+/**
+ * Policies describing attributes or characteristics of the driver's storage service,
+ * to direct how other components interact with the driver
+ */
+export declare interface IDocumentStorageServicePolicies {
+    /**
+     * Should the Loader implement any sort of pre-fetching or caching mechanism?
+     */
+    readonly caching?: LoaderCachingPolicy;
+    /**
+     * IMPORTANT: This policy MUST be set to 5 days and PROPERLY ENFORCED for drivers that are used
+     * in applications where Garbage Collection is enabled. Otherwise data loss may occur.
+     *
+     * This policy pertains to requests for the latest snapshot from the service.
+     * If set, it means that the driver guarantees not to use a cached value that was fetched more than 5 days ago.
+     * If undefined, the driver makes no guarantees about the age of snapshots used for loading.
+     */
+    readonly maximumCacheDurationMs?: FiveDaysMs;
+}
+
+/**
+ * Having this uber interface without types that have their own interfaces
+ * allows compiler to differentiate interfaces based on error type
+ */
+export declare interface IDriverBasicError extends IDriverErrorBase {
+    readonly errorType: DriverErrorType.genericError | DriverErrorType.fileNotFoundOrAccessDeniedError | DriverErrorType.offlineError | DriverErrorType.unsupportedClientProtocolVersion | DriverErrorType.writeError | DriverErrorType.fetchFailure | DriverErrorType.fetchTokenError | DriverErrorType.incorrectServerResponse | DriverErrorType.fileOverwrittenInStorage | DriverErrorType.fluidInvalidSchema | DriverErrorType.usageError | DriverErrorType.fileIsLocked | DriverErrorType.outOfStorageError;
+    readonly statusCode?: number;
+}
+
+/**
+ * Base interface for all errors and warnings
+ */
+export declare interface IDriverErrorBase {
+    /**
+     * Classification of what type of error this is, used programmatically by consumers to interpret the error.
+     *
+     * @privateRemarks TODO: use {@link DriverErrorTypes} instead (breaking change).
+     */
+    readonly errorType: DriverErrorType;
+    /**
+     * Free-form error message
+     */
+    readonly message: string;
+    /**
+     * True indicates the caller may retry the failed action. False indicates it's a fatal error
+     */
+    canRetry: boolean;
+    /**
+     * Best guess as to network conditions (online/offline) when the error arose.
+     * See OnlineStatus enum in driver-utils package for expected values.
+     */
+    online?: string;
+    /**
+     * Whether service was reachable and we got some response from service.
+     */
+    endpointReached?: boolean;
+}
+
+export declare interface IDriverHeader {
+    [DriverHeader.summarizingClient]: boolean;
+    [DriverHeader.createNew]: any;
+}
+
+export declare interface IGenericNetworkError extends IDriverErrorBase {
+    readonly errorType: DriverErrorType.genericNetworkError;
+    readonly statusCode?: number;
+}
+
+export declare interface ILocationRedirectionError extends IDriverErrorBase {
+    readonly errorType: DriverErrorType.locationRedirection;
+    readonly redirectUrl: IResolvedUrl;
+}
+
+export declare interface IResolvedUrl {
+    type: "fluid";
+    /**
+     * The id of the container this resolved url is for.
+     */
+    id: string;
+    url: string;
+    tokens: {
+        [name: string]: string;
+    };
+    endpoints: {
+        [name: string]: string;
+    };
+}
+
+/**
+ * Read interface for the Queue
+ */
+export declare interface IStream<T> {
+    read(): Promise<IStreamResult<T>>;
+}
+
+export declare type IStreamResult<T> = {
+    done: true;
+} | {
+    done: false;
+    value: T;
+};
+
+/**
+ * Context for uploading a summary to storage.
+ * Indicates the previously acked summary.
+ */
+export declare interface ISummaryContext {
+    /**
+     * Parent summary proposed handle (from summary op)
+     */
+    readonly proposalHandle: string | undefined;
+    /**
+     * Parent summary acked handle (from summary ack)
+     */
+    readonly ackHandle: string | undefined;
+    readonly referenceSequenceNumber: number;
+}
+
+export declare interface IThrottlingWarning extends IDriverErrorBase {
+    readonly errorType: DriverErrorType.throttlingError;
+    readonly retryAfterSeconds: number;
+}
+
+export declare interface IUrlResolver {
+    resolve(request: IRequest): Promise<IResolvedUrl | undefined>;
+    /**
+     * Creates a url for the created container with any data store path given in the relative url.
+     * @param resolvedUrl - resolved url for the container.
+     * @param relativeUrl - relative url containing data store path; '/' represents root path.
+     * @param packageInfoSource - optional, represents container package information to be included in url.
+     * @returns absolute url combining container url with dta store path and optional additional information.
+     */
+    getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string, packageInfoSource?: IContainerPackageInfo): Promise<string>;
+}
+
+export declare enum LoaderCachingPolicy {
+    /**
+     * The loader should not implement any prefetching or caching policy.
+     */
+    NoCaching = 0,
+    /**
+     * The loader should implement prefetching policy, i.e. it should prefetch resources from the latest snapshot.
+     */
+    Prefetch = 1
+}
+
+export { }