@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/lib/odsp-driver-untrimmed.d.mts

@@ -0,0 +1,566 @@
+import { DriverPreCheckInfo } from '@fluidframework/driver-definitions';
+import { HostStoragePolicy } from '@fluidframework/odsp-driver-definitions';
+import { IContainerPackageInfo } from '@fluidframework/driver-definitions';
+import { IdentityType } from '@fluidframework/odsp-driver-definitions';
+import { IDocumentService } from '@fluidframework/driver-definitions';
+import { IDocumentServiceFactory } from '@fluidframework/driver-definitions';
+import { IEntry } from '@fluidframework/odsp-driver-definitions';
+import { IFileEntry } from '@fluidframework/odsp-driver-definitions';
+import { IOdspResolvedUrl } from '@fluidframework/odsp-driver-definitions';
+import { IOdspUrlParts } from '@fluidframework/odsp-driver-definitions';
+import { IPersistedCache } from '@fluidframework/odsp-driver-definitions';
+import { IPrefetchSnapshotContents as IPrefetchSnapshotContents_2 } from './odspCache';
+import { IRelaySessionAwareDriverFactory } from '@fluidframework/odsp-driver-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IResolvedUrl } from '@fluidframework/driver-definitions';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharingLinkKind } from '@fluidframework/odsp-driver-definitions';
+import { ISnapshotOptions } from '@fluidframework/odsp-driver-definitions';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { ISocketStorageDiscovery } from '@fluidframework/odsp-driver-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { ITelemetryLogger } from '@fluidframework/core-interfaces';
+import { ITelemetryLoggerExt } from '@fluidframework/telemetry-utils';
+import { ITelemetryProperties } from '@fluidframework/core-interfaces';
+import { IUrlResolver } from '@fluidframework/driver-definitions';
+import { OdspResourceTokenFetchOptions } from '@fluidframework/odsp-driver-definitions';
+import { PromiseCache } from '@fluidframework/core-utils';
+import { RateLimiter } from '@fluidframework/driver-utils';
+import { ShareLinkTypes } from '@fluidframework/odsp-driver-definitions';
+import { TokenFetcher } from '@fluidframework/odsp-driver-definitions';
+
+/**
+ * A check that returns DriverPreCheckInfo if the URL format is likely supported by this driver.
+ * Note that returning information here is NOT a full guarantee that resolve will ultimately be successful.
+ * Instead, this should be used as a lightweight check that can filter out easily detectable unsupported URLs
+ * before the entire Fluid loading process needs to be kicked off.
+ * @alpha
+ */
+export declare function checkUrl(documentUrl: URL): DriverPreCheckInfo | undefined;
+
+/**
+ * @internal
+ */
+export declare enum ClpCompliantAppHeader {
+    isClpCompliantApp = "X-CLP-Compliant-App"
+}
+
+/**
+ * @alpha
+ */
+export declare function createLocalOdspDocumentServiceFactory(localSnapshot: Uint8Array | string): IDocumentServiceFactory;
+
+/**
+ * Create the request object with url and headers for creating a new file on OneDrive Sharepoint
+ * @param siteUrl - Base url for OneDrive
+ * @param driveId - drive identifier
+ * @param filePath - path where file needs to be created
+ * @param fileName - name of the new file to be created
+ * @param createShareLinkType - type of sharing link you would like to create for this file. ShareLinkTypes
+ * will be deprecated soon, so for any new implementation please provide createShareLinkType of type ShareLink
+ * @alpha
+ */
+export declare function createOdspCreateContainerRequest(siteUrl: string, driveId: string, filePath: string, fileName: string, createShareLinkType?: ShareLinkTypes | ISharingLinkKind): IRequest;
+
+/**
+ * Encodes ODC/SPO information into a URL format that can be handled by the Loader
+ * @param l -The property bag of necessary properties to locate a Fluid data store and craft a url for it
+ * @alpha
+ */
+export declare function createOdspUrl(l: OdspFluidDataStoreLocator): string;
+
+/**
+ * Transforms given Fluid data store locator into string that can be embedded into url
+ * @param locator - describes Fluid data store locator info to be encoded
+ * @returns string representing encoded Fluid data store locator info
+ * @alpha
+ */
+export declare function encodeOdspFluidDataStoreLocator(locator: OdspFluidDataStoreLocator): string;
+
+/**
+ * In ODSP, the concept of "epoch" refers to binary updates to files. For example, this might include using
+ * version restore, or if the user downloads a Fluid file and then uploads it again. These result in the epoch
+ * value being incremented.
+ *
+ * The implications of these binary updates is that the Fluid state is disrupted: the sequence number might
+ * go backwards, the data might be inconsistent with the latest state of collaboration, etc. As a result, it's
+ * not safe to continue collaboration across an epoch change. We need to detect these epoch changes and
+ * error out from the collaboration.
+ *
+ * This class is a wrapper around fetch calls. It adds epoch to the request made so that the
+ * server can match it with its epoch value in order to match the version.
+ * It also validates the epoch value received in response of fetch calls. If the epoch does not match,
+ * then it also clears all the cached entries for the given container.
+ * @alpha
+ */
+export declare class EpochTracker implements IPersistedFileCache {
+    protected readonly cache: IPersistedCache;
+    protected readonly fileEntry: IFileEntry;
+    protected readonly logger: ITelemetryLoggerExt;
+    protected readonly clientIsSummarizer?: boolean | undefined;
+    private _fluidEpoch;
+    private readonly snapshotCacheExpiryTimeoutMs;
+    readonly rateLimiter: RateLimiter;
+    private readonly driverId;
+    private networkCallNumber;
+    constructor(cache: IPersistedCache, fileEntry: IFileEntry, logger: ITelemetryLoggerExt, clientIsSummarizer?: boolean | undefined);
+    setEpoch(epoch: string, fromCache: boolean, fetchType: FetchTypeInternal): void;
+    get(entry: IEntry): Promise<any>;
+    put(entry: IEntry, value: any): Promise<void>;
+    removeEntries(): Promise<void>;
+    get fluidEpoch(): string | undefined;
+    validateEpoch(epoch: string | undefined, fetchType: FetchType): Promise<void>;
+    /**
+     * Api to fetch the response for given request and parse it as json.
+     * @param url - url of the request
+     * @param fetchOptions - fetch options for request containing body, headers etc.
+     * @param fetchType - method for which fetch is called.
+     * @param addInBody - Pass True if caller wants to add epoch in post body.
+     * @param fetchReason - fetch reason to add to the request.
+     */
+    fetchAndParseAsJSON<T>(url: string, fetchOptions: RequestInit, fetchType: FetchType, addInBody?: boolean, fetchReason?: string): Promise<IOdspResponse<T>>;
+    /**
+     * Api to fetch the response for given request and parse it as json.
+     * @param url - url of the request
+     * @param fetchOptions - fetch options for request containing body, headers etc.
+     * @param fetchType - method for which fetch is called.
+     * @param addInBody - Pass True if caller wants to add epoch in post body.
+     * @param fetchReason - fetch reason to add to the request.
+     */
+    fetch(url: string, fetchOptions: RequestInit, fetchType: FetchType, addInBody?: boolean, fetchReason?: string): Promise<IOdspResponse<Response>>;
+    private fetchCore;
+    /**
+     * Api to fetch the response as it is for given request.
+     * @param url - url of the request
+     * @param fetchOptions - fetch options for request containing body, headers etc.
+     * @param fetchType - method for which fetch is called.
+     * @param addInBody - Pass True if caller wants to add epoch in post body.
+     * @param fetchReason - fetch reason to add to the request.
+     */
+    fetchArray(url: string, fetchOptions: {
+        [index: string]: any;
+    }, fetchType: FetchType, addInBody?: boolean, fetchReason?: string): Promise<IOdspResponse<ArrayBuffer>>;
+    private addEpochInRequest;
+    private addParamInBody;
+    private formatClientCorrelationId;
+    protected validateEpochFromResponse(epochFromResponse: string | undefined, fetchType: FetchTypeInternal, fromCache?: boolean): void;
+    private checkForEpochError;
+    private checkForEpochErrorCore;
+    private fileEntryFromEntry;
+}
+
+/**
+ * @alpha
+ */
+export declare type FetchType = "blob" | "createBlob" | "createFile" | "joinSession" | "ops" | "test" | "snapshotTree" | "treesLatest" | "uploadSummary" | "push" | "versions";
+
+/**
+ * @alpha
+ */
+export declare type FetchTypeInternal = FetchType | "cache";
+
+/**
+ * Gets the correct API root for the given ODSP url, e.g. 'https://foo-my.sharepoint.com/_api/v2.1'
+ * @param origin - The URL origin
+ * @internal
+ */
+export declare function getApiRoot(origin: string): string;
+
+/**
+ * @alpha
+ */
+export declare function getHashedDocumentId(driveId: string, itemId: string): Promise<string>;
+
+/**
+ * Extract ODSP Fluid data store locator object from given ODSP url. This extracts things like
+ * driveId, ItemId, siteUrl etc from a url where these are encoded in nav query param.
+ * @param url - ODSP url representing Fluid file link
+ * @param requireFluidSignature - flag representing if the Fluid signature is expected in the url, default true
+ * @returns object representing Fluid data store location in ODSP terms
+ * @alpha
+ */
+export declare function getLocatorFromOdspUrl(url: URL, requireFluidSignature?: boolean): OdspFluidDataStoreLocator | undefined;
+
+/**
+ * Breaks an ODSP URL into its parts, extracting the site, drive ID, and item ID.
+ * Returns undefined for invalid/malformed URLs.
+ * @param url - The (raw) URL to parse
+ * @internal
+ */
+export declare function getOdspUrlParts(url: URL): Promise<IOdspUrlParts | undefined>;
+
+/**
+ * @alpha
+ */
+export declare interface ICacheAndTracker {
+    cache: IOdspCache;
+    epochTracker: EpochTracker;
+}
+
+/**
+ * @internal
+ */
+export declare interface IClpCompliantAppHeader {
+    [ClpCompliantAppHeader.isClpCompliantApp]: boolean;
+}
+
+/**
+ * Internal cache interface used within driver only
+ * @alpha
+ */
+export declare interface INonPersistentCache {
+    /**
+     * Cache of joined/joining session info
+     */
+    readonly sessionJoinCache: PromiseCache<string, {
+        entryTime: number;
+        joinSessionResponse: ISocketStorageDiscovery;
+    }>;
+    /**
+     * Cache of resolved/resolving file URLs
+     */
+    readonly fileUrlCache: PromiseCache<string, IOdspResolvedUrl>;
+    /**
+     * Used to store the snapshot fetch promise if the prefetch has been made using the prefetchLatestSnapshot api.
+     * This is then used later to look for the promise during the container load.
+     */
+    readonly snapshotPrefetchResultCache: PromiseCache<string, IPrefetchSnapshotContents>;
+}
+
+/**
+ * Internal cache interface used within driver only
+ * @alpha
+ */
+export declare interface IOdspCache extends INonPersistentCache {
+    /**
+     * Persisted cache - only serializable content is allowed
+     */
+    readonly persistedCache: IPersistedFileCache;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IOdspResponse<T> {
+    content: T;
+    headers: Map<string, string>;
+    propsToLog: ITelemetryProperties;
+    duration: number;
+}
+
+/**
+ * Similar to IPersistedCache, but exposes cache interface for single file
+ * @alpha
+ */
+export declare interface IPersistedFileCache {
+    get(entry: IEntry): Promise<any>;
+    put(entry: IEntry, value: any): Promise<void>;
+    removeEntries(): Promise<void>;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IPrefetchSnapshotContents extends ISnapshotContents {
+    fluidEpoch: string;
+    prefetchStartTime: number;
+}
+
+/**
+ * @internal
+ */
+export declare interface ISharingLinkHeader {
+    [SharingLinkHeader.isSharingLinkToRedeem]: boolean;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISnapshotContents {
+    snapshotTree: ISnapshotTree;
+    blobs: Map<string, ArrayBuffer>;
+    ops: ISequencedDocumentMessage[];
+    /**
+     * Sequence number of the snapshot
+     */
+    sequenceNumber: number | undefined;
+    /**
+     * Sequence number for the latest op/snapshot for the file in ODSP
+     */
+    latestSequenceNumber: number | undefined;
+}
+
+/**
+ * The parsing is significantly faster if the position of props is well known instead of dynamic. So these variables
+ * represents how many times slower parsing path is executed. This will be then logged into telemetry.
+ * @internal
+ */
+export declare interface ISnapshotContentsWithProps extends ISnapshotContents {
+    telemetryProps: Record<string, number>;
+}
+
+/**
+ * Checks whether or not the given URL origin is an ODC origin
+ * @param origin - The URL origin to check
+ * @internal
+ */
+export declare function isOdcOrigin(origin: string): boolean;
+
+/**
+ * Whether or not the given URL is a valid ODC URL
+ * @param url - The URL to check
+ * @internal
+ */
+export declare function isOdcUrl(url: string | URL): boolean;
+
+/**
+ * @internal
+ */
+export declare function isOdspResolvedUrl(resolvedUrl: IResolvedUrl): resolvedUrl is IOdspResolvedUrl;
+
+/**
+ * Whether or not the given URL is a valid SPO/ODB URL
+ * @param url - The URL to check
+ * @internal
+ */
+export declare function isSpoUrl(url: string): boolean;
+
+/**
+ * This parameter is provided by host in the resolve request and it contains information about the file
+ * like driveId, itemId, siteUrl, datastorePath, packageName etc.
+ * @alpha
+ */
+export declare const locatorQueryParamName = "nav";
+
+/**
+ * @alpha
+ */
+export declare const OdcApiSiteOrigin = "https://my.microsoftpersonalcontent.com";
+
+/**
+ * @alpha
+ */
+export declare const OdcFileSiteOrigin = "https://1drv.ms";
+
+/**
+ * Factory for creating the sharepoint document service. Use this if you want to
+ * use the sharepoint implementation.
+ * @alpha
+ */
+export declare class OdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
+    constructor(getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>, getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined, persistedCache?: IPersistedCache, hostPolicy?: HostStoragePolicy);
+}
+
+/**
+ * Factory for creating the sharepoint document service. Use this if you want to
+ * use the sharepoint implementation.
+ *
+ * This constructor should be used by environments that support dynamic imports and that wish
+ * to leverage code splitting as a means to keep bundles as small as possible.
+ * @alpha
+ */
+export declare class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory, IRelaySessionAwareDriverFactory {
+    private readonly getStorageToken;
+    private readonly getWebsocketToken;
+    protected persistedCache: IPersistedCache;
+    private readonly hostPolicy;
+    private readonly nonPersistentCache;
+    private readonly socketReferenceKeyPrefix?;
+    get snapshotPrefetchResultCache(): PromiseCache<string, IPrefetchSnapshotContents_2>;
+    get IRelaySessionAwareDriverFactory(): this;
+    /**
+     * This function would return info about relay service session only if this factory established (or attempted to
+     * establish) connection very recently. Otherwise, it will return undefined.
+     * @param resolvedUrl - resolved url for container
+     * @returns The current join session response stored in cache. `undefined` if not present.
+     */
+    getRelayServiceSessionInfo(resolvedUrl: IResolvedUrl): Promise<ISocketStorageDiscovery | undefined>;
+    createContainer(createNewSummary: ISummaryTree | undefined, createNewResolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+    /**
+     * @param getStorageToken - function that can provide the storage token for a given site. This is
+     * is also referred to as the "Vroom" token in SPO.
+     * @param getWebsocketToken - function that can provide a token for accessing the web socket. This is also
+     * to as the "Push" token in SPO. If undefined then websocket token is expected to be returned with joinSession
+     * response payload.
+     * @param persistedCache - PersistedCache provided by host for use in this session.
+     * @param hostPolicy - Policy for storage provided by host.
+     */
+    constructor(getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>, getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined, persistedCache?: IPersistedCache, hostPolicy?: HostStoragePolicy);
+    createDocumentService(resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+    protected createDocumentServiceCore(resolvedUrl: IResolvedUrl, odspLogger: ITelemetryLogger, cacheAndTrackerArg?: ICacheAndTracker, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+}
+
+/**
+ * @deprecated This is deprecated in favour of OdspDocumentServiceFactory as the socket io is now loaded inside the
+ * other dynamically imported module.
+ * @internal
+ */
+export declare class OdspDocumentServiceFactoryWithCodeSplit extends OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
+    constructor(getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>, getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined, persistedCache?: IPersistedCache, hostPolicy?: HostStoragePolicy);
+}
+
+/**
+ * Resolver to resolve urls like the ones created by createOdspUrl which is driver inner
+ * url format. Ex: `${siteUrl}?driveId=${driveId}&itemId=${itemId}&path=${path}`
+ * @alpha
+ */
+export declare class OdspDriverUrlResolver implements IUrlResolver {
+    constructor();
+    /**
+     * @alpha
+     */
+    resolve(request: IRequest): Promise<IOdspResolvedUrl>;
+    /**
+     * Requests a driver + data store storage URL.
+     * @param resolvedUrl - The driver resolved URL.
+     * @param relativeUrl - The relative data store path URL.
+     * For requesting a driver URL, this value should always be '/'. If an empty string is passed, then dataStorePath
+     * will be extracted from the resolved url if present.
+     * @param packageInfoSource - optional, represents container package information to be included in url.
+     */
+    getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string, packageInfoSource?: IContainerPackageInfo): Promise<string>;
+}
+
+/**
+ * Resolver to resolve urls like the ones created by createOdspUrl which is driver inner
+ * url format and the ones which have things like driveId, siteId, itemId etc encoded in nav param.
+ * This resolver also handles share links and try to generate one for the use by the app.
+ * @alpha
+ */
+export declare class OdspDriverUrlResolverForShareLink implements IUrlResolver {
+    private readonly appName?;
+    private readonly getContext?;
+    private readonly logger;
+    private readonly sharingLinkCache;
+    private readonly shareLinkFetcherProps;
+    /**
+     * Creates url resolver instance
+     * @param shareLinkFetcherProps - properties used when fetching share link.
+     * Can be set as 'undefined' for cases where share link is not needed. Currently, only
+     * getAbsoluteUrl() method requires share link.
+     * @param logger - logger object that is used as telemetry sink
+     * @param appName - application name hint that is encoded with url produced by getAbsoluteUrl() method.
+     * This hint is used by link handling logic which determines which app to redirect to when user
+     * navigates directly to the link.
+     * @param getContext - callback function which is used to get context for given resolved url. If context
+     * is returned then it will be embedded into url returned by getAbsoluteUrl() method.
+     */
+    constructor(shareLinkFetcherProps?: ShareLinkFetcherProps | undefined, logger?: ITelemetryBaseLogger, appName?: string | undefined, getContext?: ((resolvedUrl: IOdspResolvedUrl, dataStorePath: string) => Promise<string | undefined>) | undefined);
+    /**
+     * Takes an already generated data store url (from requestUrl) and appends a path to the
+     * existing data store information.
+     */
+    appendDataStorePath(requestUrl: URL, pathToAppend: string): string | undefined;
+    private getKey;
+    /**
+     * Resolves request URL into driver details
+     */
+    resolve(request: IRequest): Promise<IOdspResolvedUrl>;
+    private removeNavParam;
+    private getShareLinkPromise;
+    /**
+     * Requests a driver + data store storage URL. Note that this method requires share link to be fetched
+     * and it will throw in case share link fetcher props were not specified when instance was created.
+     * @param resolvedUrl - The driver resolved URL
+     * @param dataStorePath - The relative data store path URL.
+     * For requesting a driver URL, this value should always be '/'. If an empty string is passed, then dataStorePath
+     * will be extracted from the resolved url if present.
+     * @param packageInfoSource - optional, represents container package information to be included in url.
+     */
+    getAbsoluteUrl(resolvedUrl: IResolvedUrl, dataStorePath: string, packageInfoSource?: IContainerPackageInfo): Promise<string>;
+    /**
+     * Crafts a supported document/driver URL
+     */
+    static createDocumentUrl(baseUrl: string, driverInfo: OdspFluidDataStoreLocator): string;
+    /**
+     * Crafts a supported data store nav param
+     * @deprecated encodeOdspFluidDataStoreLocator should be used instead
+     */
+    static createNavParam(locator: OdspFluidDataStoreLocator): string;
+}
+
+/**
+ * @alpha
+ */
+export declare interface OdspFluidDataStoreLocator extends IOdspUrlParts {
+    dataStorePath: string;
+    appName?: string;
+    containerPackageName?: string;
+    fileVersion?: string;
+    context?: string;
+}
+
+/**
+ * Converts snapshot from binary compact representation to tree/blobs/ops.
+ * @param buffer - Compact snapshot to be parsed into tree/blobs/ops.
+ * @returns Tree, blobs and ops from the snapshot.
+ * @internal
+ */
+export declare function parseCompactSnapshotResponse(buffer: Uint8Array, logger: ITelemetryLoggerExt): ISnapshotContentsWithProps;
+
+/**
+ * Function to prefetch the snapshot and cached it in the persistant cache, so that when the container is loaded
+ * the cached latest snapshot could be used and removes the network call from the critical path.
+ *
+ * @param resolvedUrl - Resolved url to fetch the snapshot.
+ * @param getStorageToken - function that can provide the storage token for a given site. This is
+ * is also referred to as the "VROOM" token in SPO.
+ * @param persistedCache - Cache to store the fetched snapshot.
+ * @param forceAccessTokenViaAuthorizationHeader - whether to force passing given token via authorization header.
+ * @param logger - Logger to have telemetry events.
+ * @param hostSnapshotFetchOptions - Options to fetch the snapshot if any. Otherwise default will be used.
+ * @param enableRedeemFallback - True to have the sharing link redeem fallback in case the Trees Latest/Redeem
+ * 1RT call fails with redeem error. During fallback it will first redeem the sharing link and then make
+ * the Trees latest call.
+ * Note: this can be considered deprecated - it will be replaced with `snapshotFormatFetchType`.
+ * @param fetchBinarySnapshotFormat - Control if we want to fetch binary format snapshot.
+ * @param snapshotFormatFetchType - Snapshot format to fetch.
+ * @param odspDocumentServiceFactory - factory to access the non persistent cache and store the prefetch promise.
+ *
+ * @returns `true` if the snapshot is cached, `false` otherwise.
+ * @alpha
+ */
+export declare function prefetchLatestSnapshot(resolvedUrl: IResolvedUrl, getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>, persistedCache: IPersistedCache, forceAccessTokenViaAuthorizationHeader: boolean, logger: ITelemetryBaseLogger, hostSnapshotFetchOptions: ISnapshotOptions | undefined, enableRedeemFallback?: boolean, fetchBinarySnapshotFormat?: boolean, snapshotFormatFetchType?: SnapshotFormatSupportType, odspDocumentServiceFactory?: OdspDocumentServiceFactory): Promise<boolean>;
+
+/**
+ * Properties passed to the code responsible for fetching share link for a file.
+ * @alpha
+ */
+export declare interface ShareLinkFetcherProps {
+    /**
+     * Callback method that is used to fetch access token necessary to call API that produces share link
+     */
+    tokenFetcher: TokenFetcher<OdspResourceTokenFetchOptions>;
+    /**
+     * Identity type determining the shape of share link as it differs for Enterprise and Consumer users.
+     */
+    identityType: IdentityType;
+}
+
+/**
+ * @internal
+ */
+export declare enum SharingLinkHeader {
+    isSharingLinkToRedeem = "isSharingLinkToRedeem"
+}
+
+/**
+ * Enum to support different types of snapshot formats.
+ * @alpha
+ */
+export declare enum SnapshotFormatSupportType {
+    Json = 0,
+    Binary = 1,
+    JsonAndBinary = 2
+}
+
+/**
+ * Embeds Fluid data store locator data into given ODSP url
+ * @param url - file url in ODSP format (can be either canonical or share link)
+ * @param locator - object representing Fluid data store location in ODSP terms
+ * @alpha
+ */
+export declare function storeLocatorInOdspUrl(url: URL, locator: OdspFluidDataStoreLocator): void;
+
+export { }

package/lib/{odspCache.d.ts → odspCache.d.mts}

@@ -1,12 +1,9 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { PromiseCache } from "@fluidframework/common-utils";
-import { IOdspResolvedUrl, IFileEntry, IEntry, IPersistedCache, ICacheEntry } from "@fluidframework/odsp-driver-definitions";
-import { ISocketStorageDiscovery } from "./contracts";
+import { PromiseCache } from "@fluidframework/core-utils";
+import { IOdspResolvedUrl, IFileEntry, IEntry, IPersistedCache, ICacheEntry, ISocketStorageDiscovery } from "@fluidframework/odsp-driver-definitions";
+import { ISnapshotContents } from "./odspPublicUtils.mjs";
 /**
  * Similar to IPersistedCache, but exposes cache interface for single file
+ * @alpha
  */
 export interface IPersistedFileCache {
     get(entry: IEntry): Promise<any>;
@@ -28,13 +25,13 @@ export declare class LocalPersistentCache implements IPersistedCache {
     private removeDocIdEntriesFromCache;
     private removeExpirationEntry;
     private updateExpirationEntry;
-    private keyFromEntry;
 }
 export declare class PromiseCacheWithOneHourSlidingExpiry<T> extends PromiseCache<string, T> {
     constructor(removeOnError?: (e: any) => boolean);
 }
 /**
  * Internal cache interface used within driver only
+ * @alpha
  */
 export interface INonPersistentCache {
     /**
@@ -48,9 +45,15 @@ export interface INonPersistentCache {
      * Cache of resolved/resolving file URLs
      */
     readonly fileUrlCache: PromiseCache<string, IOdspResolvedUrl>;
+    /**
+     * Used to store the snapshot fetch promise if the prefetch has been made using the prefetchLatestSnapshot api.
+     * This is then used later to look for the promise during the container load.
+     */
+    readonly snapshotPrefetchResultCache: PromiseCache<string, IPrefetchSnapshotContents>;
 }
 /**
  * Internal cache interface used within driver only
+ * @alpha
  */
 export interface IOdspCache extends INonPersistentCache {
     /**
@@ -64,5 +67,13 @@ export declare class NonPersistentCache implements INonPersistentCache {
         joinSessionResponse: ISocketStorageDiscovery;
     }>;
     readonly fileUrlCache: PromiseCache<string, IOdspResolvedUrl>;
+    readonly snapshotPrefetchResultCache: PromiseCache<string, IPrefetchSnapshotContents>;
+}
+/**
+ * @alpha
+ */
+export interface IPrefetchSnapshotContents extends ISnapshotContents {
+    fluidEpoch: string;
+    prefetchStartTime: number;
 }
 //# sourceMappingURL=odspCache.d.ts.map

package/lib/odspCache.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odspCache.d.ts","sourceRoot":"","sources":["../src/odspCache.ts"],"names":[],"mappings":"OAIO,EAAE,YAAY,EAAE,MAAM,4BAA4B;OAClD,EACN,gBAAgB,EAChB,UAAU,EACV,MAAM,EACN,eAAe,EACf,WAAW,EACX,uBAAuB,EAEvB,MAAM,yCAAyC;OACzC,EAAE,iBAAiB,EAAE;AAE5B;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IACnC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACjC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,eAAe;IAKxC,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAJxD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAEhD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoD;gBAEnD,oBAAoB,SAAc;IAEhE,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;IAMrC,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG;IAMlC,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD,OAAO,CAAC,2BAA2B;IAcnC,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,qBAAqB;CAS7B;AACD,qBAAa,oCAAoC,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;gBACvE,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAO;CAG/C;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IACnC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CACtC,MAAM,EACN;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,uBAAuB,CAAA;KAAE,CACnE,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAE9D;;;OAGG;IACH,QAAQ,CAAC,2BAA2B,EAAE,YAAY,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;CACtF;AAED;;;GAGG;AACH,MAAM,WAAW,UAAW,SAAQ,mBAAmB;IACtD;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;CAC7C;AAED,qBAAa,kBAAmB,YAAW,mBAAmB;IAC7D,SAAgB,gBAAgB;mBAElB,MAAM;6BAAuB,uBAAuB;OAC9D;IAEJ,SAAgB,YAAY,yCAAgD;IAE5E,SAAgB,2BAA2B,kDAGvC;CACJ;AAED;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,iBAAiB;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC1B"}

package/lib/{odspCache.js → odspCache.mjs}

@@ -1,8 +1,5 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { PromiseCache } from "@fluidframework/common-utils";
+import { PromiseCache } from "@fluidframework/core-utils";
+import { getKeyForCacheEntry, } from "@fluidframework/odsp-driver-definitions";
 /**
  * Default local-only implementation of IPersistedCache,
  * used if no persisted cache is provided by the host
@@ -15,12 +12,12 @@ export class LocalPersistentCache {
         this.docIdExpirationMap = new Map();
     }
     async get(entry) {
-        const key = this.keyFromEntry(entry);
+        const key = getKeyForCacheEntry(entry);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return this.cache.get(key);
     }
     async put(entry, value) {
-        const key = this.keyFromEntry(entry);
+        const key = getKeyForCacheEntry(entry);
         this.cache.set(key, value);
         this.updateExpirationEntry(entry.file.docId);
     }
@@ -53,9 +50,6 @@ export class LocalPersistentCache {
             this.removeDocIdEntriesFromCache(docId);
         }, this.snapshotExpiryPolicy));
     }
-    keyFromEntry(entry) {
-        return `${entry.file.docId}_${entry.type}_${entry.key}`;
-    }
 }
 export class PromiseCacheWithOneHourSlidingExpiry extends PromiseCache {
     constructor(removeOnError) {
@@ -66,6 +60,7 @@ export class NonPersistentCache {
     constructor() {
         this.sessionJoinCache = new PromiseCache();
         this.fileUrlCache = new PromiseCache();
+        this.snapshotPrefetchResultCache = new PromiseCache();
     }
 }
-//# sourceMappingURL=odspCache.js.map
+//# sourceMappingURL=odspCache.mjs.map