@salesforce/lds-runtime-mobile 1.319.0 → 1.321.0

package/dist/types/adapters/wire/getRelatedListRecordsBatch/index.d.ts

@@ -0,0 +1,29 @@
+import type { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import type { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from '../../util/adapter-utils';
+import type { RelatedListRecordsSingleBatchInputRepresentation as types_RelatedListRecordsSingleBatchInputRepresentation_RelatedListRecordsSingleBatchInputRepresentation } from '../../types/RelatedListRecordsSingleBatchInputRepresentation';
+import type { ResourceRequestConfig as resources_postUiApiRelatedListRecordsBatchByParentRecordId_ResourceRequestConfig } from '../../resources/postUiApiRelatedListRecordsBatchByParentRecordId';
+import type { RelatedListRecordCollectionBatchRepresentation as types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation } from '../../types/RelatedListRecordCollectionBatchRepresentation';
+export declare const adapterName = "getRelatedListRecordsBatch";
+export declare const getRelatedListRecordsBatch_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getRelatedListRecordsBatch_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetRelatedListRecordsBatchConfig {
+    parentRecordId: string;
+    relatedListParameters: Array<types_RelatedListRecordsSingleBatchInputRepresentation_RelatedListRecordsSingleBatchInputRepresentation>;
+}
+export declare const createResourceParams: (config: GetRelatedListRecordsBatchConfig) => resources_postUiApiRelatedListRecordsBatchByParentRecordId_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetRelatedListRecordsBatchConfig>): adapter$45$utils_Untrusted<GetRelatedListRecordsBatchConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetRelatedListRecordsBatchConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig): $64$luvio_engine_Snapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig, resourceParams: resources_postUiApiRelatedListRecordsBatchByParentRecordId_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any> | import("@luvio/engine").StaleSnapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any> | import("@luvio/engine").PendingSnapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig, resourceParams: resources_postUiApiRelatedListRecordsBatchByParentRecordId_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetRelatedListRecordsBatchConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetRelatedListRecordsBatchConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation>): $64$luvio_engine_Snapshot<types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation, any>;
+export declare const getRelatedListRecordsBatchAdapterFactory: $64$luvio_engine_AdapterFactory<GetRelatedListRecordsBatchConfig, types_RelatedListRecordCollectionBatchRepresentation_RelatedListRecordCollectionBatchRepresentation>;

package/dist/types/adapters/wire/getSearchResults/index.d.ts

@@ -0,0 +1,34 @@
+import type { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import type { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from '../../util/adapter-utils';
+import type { SearchObjectOptionsRepresentation as types_SearchObjectOptionsRepresentation_SearchObjectOptionsRepresentation } from '../../types/SearchObjectOptionsRepresentation';
+import type { ResourceRequestConfig as resources_postUiApiSearchResults_ResourceRequestConfig } from '../../resources/postUiApiSearchResults';
+import type { SearchResultsSummaryRepresentation as types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation } from '../../types/SearchResultsSummaryRepresentation';
+export declare const adapterName = "getSearchResults";
+export declare const getSearchResults_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getSearchResults_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetSearchResultsConfig {
+    q: string;
+    answerTypes?: Array<string>;
+    configurationName?: string;
+    objectApiNames?: Array<string>;
+    searchObjectOptions?: {
+        [key: string]: types_SearchObjectOptionsRepresentation_SearchObjectOptionsRepresentation;
+    };
+}
+export declare const createResourceParams: (config: GetSearchResultsConfig) => resources_postUiApiSearchResults_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetSearchResultsConfig>): adapter$45$utils_Untrusted<GetSearchResultsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetSearchResultsConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig): $64$luvio_engine_Snapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig, resourceParams: resources_postUiApiSearchResults_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig, resourceParams: resources_postUiApiSearchResults_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetSearchResultsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetSearchResultsConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation>): $64$luvio_engine_Snapshot<types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation, any>;
+export declare const getSearchResultsAdapterFactory: $64$luvio_engine_AdapterFactory<GetSearchResultsConfig, types_SearchResultsSummaryRepresentation_SearchResultsSummaryRepresentation>;

package/dist/types/adapters/wire/graphqlBatch/index.d.ts

@@ -1,4 +1,4 @@
-import type { AdapterValidationConfig, Untrusted as Untrusted } from '../../generated/adapters/adapter-utils';
+import type { AdapterValidationConfig, Untrusted as Untrusted } from '../../util/adapter-utils';
 import type { Luvio, Fragment, Snapshot, FetchResponse, ErrorResponse, DispatchResourceRequestContext, CoercedAdapterRequestContext, StoreLookup, AdapterFactory } from '@luvio/engine';
 import type { ResourceRequestConfig, GraphQLBatchRepresentation } from './postGraphqlBatch';
 import type { GraphqlConfig } from '../../generated/adapters/graphql';

package/dist/types/adapters/wire/graphqlBatch/postGraphqlBatch.d.ts

@@ -1,7 +1,7 @@
 import type { FetchResponse as $64$luvio_engine_FetchResponse, Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest, NormalizedKeyMetadata, HttpStatusCode } from '@luvio/engine';
 import { StoreKeySet } from '@luvio/engine';
-import type { ResourceRequestConfig as postGraphql_ResourceRequestConfig } from '../../generated/resources/postGraphql';
-import type { GraphQLRepresentation } from '../../generated/types/GraphQLRepresentation';
+import type { ResourceRequestConfig as postGraphql_ResourceRequestConfig } from '../../resources/postGraphql';
+import type { GraphQLRepresentation } from '../../types/GraphQLRepresentation';
 import type { GraphqlConfig } from '../../generated/adapters/graphql';
 export interface ResourceRequestConfig {
     body: {

package/dist/types/drafts/AbstractResourceRequestActionHandler.d.ts

@@ -0,0 +1,70 @@
+import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
+import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue, ActionHandler } from '@salesforce/lds-drafts';
+import { ProcessActionResult } from '@salesforce/lds-drafts';
+import type { UiApiDraftRecordService } from './UiApiDraftRecordService';
+export type ResponseIngestionEntry<T = unknown> = {
+    response: T;
+    synchronousIngest: AbstractResourceRequestActionHandler<T>['synchronousIngest'];
+    buildCacheKeysForResponse: AbstractResourceRequestActionHandler<T>['buildCacheKeysFromResponse'];
+};
+export interface DraftIdAndKeyMapping {
+    draftId: string;
+    canonicalId: string;
+    draftKey: string;
+    canonicalKey: string;
+}
+export declare const DEFAULT_FIELD_LAST_MODIFIED_DATE = "LastModifiedDate";
+export declare const DEFAULT_FIELD_CREATED_DATE = "CreatedDate";
+export declare abstract class AbstractResourceRequestActionHandler<ResponseType> implements ActionHandler<ResourceRequest, ResponseType> {
+    protected readonly draftQueue: DraftQueue;
+    protected readonly networkAdapter: NetworkAdapter;
+    protected readonly getLuvio: () => Luvio;
+    protected readonly recordService: UiApiDraftRecordService;
+    isIdempotencySupported: boolean;
+    isLdsIdempotencyWriteDisabled: boolean;
+    isBackdatingEnabled: boolean;
+    constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio, recordService: UiApiDraftRecordService);
+    enqueue(data: ResourceRequest): Promise<PendingDraftAction<ResourceRequest>>;
+    buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
+    handleAction(action: DraftAction<ResourceRequest, ResponseType>, actionCompleted: (action: CompletedDraftAction<ResourceRequest, ResponseType>) => Promise<void>, actionErrored: (action: DraftAction<ResourceRequest, ResponseType>, retry: boolean, retryDelayInMs?: number, actionDataChanged?: boolean) => Promise<void>): Promise<ProcessActionResult>;
+    handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;
+    handleActionRemoved(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    handleActionReplaced(target: DraftAction<ResourceRequest, ResponseType>, source: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, ResponseType>, queueOperations: QueueOperation[]): Promise<void>;
+    getQueueOperationsForCompletingDrafts(queue: DraftAction<unknown, unknown>[], action: CompletedDraftAction<ResourceRequest, ResponseType>): QueueOperation[];
+    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, ResponseType>): DraftIdAndKeyMapping[] | undefined;
+    handleReplaceAction(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
+    mergeActions(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
+    shouldDeleteActionByTagOnRemoval(action: DraftAction<ResourceRequest, ResponseType>): boolean;
+    updateMetadata(_existingMetadata: DraftActionMetadata, incomingMetadata: DraftActionMetadata): DraftActionMetadata;
+    private isActionOfType;
+    private handleIdempotencyServerError;
+    private isUiApiErrors;
+    private isBackdatingError;
+    getDraftIdsFromAction(action: DraftAction<ResourceRequest, ResponseType>): string[];
+    hasIdempotencySupport(): boolean;
+    protected ingestResponses(responses: ResponseIngestionEntry[], action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    evictKey(key: string): Promise<void>;
+    abstract handlerId: string;
+    /**
+     * Extracts or synthesizes an id from a given resource request
+     * @throws if the id cannot be determined or synthesized
+     * @param request the request to get the id from
+     */
+    abstract getIdFromRequest(request: ResourceRequest): Promise<string>;
+    abstract getIdFromResponseBody(responseBody: ResponseType): string;
+    abstract buildTagForTargetId(id: string): string;
+    abstract buildCacheKeysFromResponse(response: ResponseType): DurableStoreKeyMetadataMap;
+    abstract synchronousIngest(response: ResponseType, action: DraftAction<ResourceRequest, ResponseType>): void;
+    /**
+     * Returns true if the given targetId is a for a draft-created record
+     *
+     * @param targetId the targetId to check
+     */
+    abstract isDraftId(targetId: string): boolean;
+    /**
+     * Overlay the sourceBody over top of the targetBody
+     */
+    abstract mergeRequestBody<T = unknown>(targetBody: T, sourceBody: T): T;
+}
+export declare function isResourceRequestAction(action: DraftAction<unknown, unknown>): action is DraftAction<ResourceRequest, unknown>;

package/dist/types/drafts/UiApiDraftRecordService.d.ts

@@ -0,0 +1,43 @@
+import type { Luvio } from '@luvio/engine';
+import type { DraftAction } from '@salesforce/lds-drafts';
+import type { FieldRepresentation, ObjectInfoService } from './utils/types';
+import type { RecordEffectingHandler } from './records/actionHandlers/RecordEffectingHandler';
+import { type DurableStore } from '@luvio/environments';
+import type { SideEffectStore } from './sideEffects';
+import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+export interface ReferenceIdFieldInfo {
+    id: string;
+    field: FieldRepresentation;
+}
+export declare class UiApiDraftRecordService {
+    private readonly getLuvio;
+    private readonly durableStore;
+    private readonly objectInfoService;
+    private readonly generateId;
+    private readonly sideEffectStore;
+    private readonly durableRecordStore;
+    private recordEffectingHandlers;
+    constructor(getLuvio: () => Luvio, durableStore: DurableStore, objectInfoService: ObjectInfoService, generateId: (prefix: string) => string, sideEffectStore: SideEffectStore, durableRecordStore: DurableRecordStore);
+    registerRecordHandler(recordHandler: RecordEffectingHandler): void;
+    setSideEffectsForActions(changedActions: DraftAction<unknown, unknown>[]): Promise<Set<string>>;
+    removeSideEffectsForAction(removedAction: DraftAction<unknown, unknown>): Promise<Set<string>>;
+    reapplyRecordSideEffects(recordKeys: Set<string>): Promise<void>;
+    synthesizeId(apiName: string): Promise<string>;
+    checkDraftPrequisites(apiName: string, fields: Record<string, any>): Promise<{
+        ok: boolean;
+        status: string;
+        fieldNames?: undefined;
+        missingRecordReferences?: undefined;
+    } | {
+        ok: boolean;
+        status: string;
+        fieldNames: string[];
+        missingRecordReferences?: undefined;
+    } | {
+        ok: boolean;
+        status: string;
+        missingRecordReferences: ReferenceIdFieldInfo[];
+        fieldNames?: undefined;
+    }>;
+    private recalculateForChangedActions;
+}

package/dist/types/drafts/contentDocument/ContentDocumentCompositeRepresentationActionHandler.d.ts

@@ -0,0 +1,51 @@
+import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
+import type { DraftIdAndKeyMapping } from '../AbstractResourceRequestActionHandler';
+import { AbstractResourceRequestActionHandler, type ResponseIngestionEntry } from '../AbstractResourceRequestActionHandler';
+import type { PendingDraftAction, DraftAction, DraftQueue, CompletedDraftAction } from '@salesforce/lds-drafts';
+import type { RecordEffectingHandler } from '../records/actionHandlers/RecordEffectingHandler';
+import type { UiApiDraftRecordService } from '../UiApiDraftRecordService';
+import { type ContentDocumentCompositeRepresentation, type CreateContentDocumentAndVersionResourceRequestConfig, type ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { BinaryStore } from '@salesforce/lds-store-binary';
+import type { ObjectInfoService } from '../utils/types';
+import { type SideEffect } from '../sideEffects/sideEffects';
+import { type SideEffectService } from '../sideEffects/SideEffectService';
+export declare const HANDLER_ID = "ContentDocumentCompositeRepresentationActionHandler";
+export interface CreateContentDocumentAndVersionResourceRequest extends Omit<ResourceRequest, 'body' | 'method'> {
+    body: CreateContentDocumentAndVersionResourceRequestConfig['body'];
+    method: 'post';
+}
+export declare class ContentDocumentCompositeRepresentationActionHandler extends AbstractResourceRequestActionHandler<ContentDocumentCompositeRepresentation> implements RecordEffectingHandler {
+    protected readonly getLuvio: () => Luvio;
+    protected readonly userId: string;
+    private readonly draftRecordService;
+    private readonly objectInfoService;
+    protected readonly draftQueue: DraftQueue;
+    protected readonly networkAdapter: NetworkAdapter;
+    readonly isDraftId: (targetId: string) => boolean;
+    private readonly binaryStore;
+    private readonly sideEffectService;
+    private binaryStoreUrlsToUpdate;
+    handlerId: string;
+    constructor(getLuvio: () => Luvio, userId: string, draftRecordService: UiApiDraftRecordService, objectInfoService: ObjectInfoService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, isDraftId: (targetId: string) => boolean, binaryStore: BinaryStore, sideEffectService: SideEffectService);
+    buildPendingAction(request: CreateContentDocumentAndVersionResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<CreateContentDocumentAndVersionResourceRequest>>;
+    getBackdatingNameEntries(objectInfo: ObjectInfoRepresentation, timestamp: number): {
+        name: string;
+        value: string | File;
+    }[];
+    getIdFromRequest(_request: ResourceRequest): Promise<string>;
+    getIdFromResponseBody(responseBody: ContentDocumentCompositeRepresentation): string;
+    buildTagForTargetId(id: string): string;
+    getIdsFromAction(action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): {
+        contentDocumentId: string;
+        contentVersionId: string;
+        contentDocumentLinkId: string;
+    };
+    handleActionRemoved(action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): Promise<void>;
+    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): DraftIdAndKeyMapping[] | undefined;
+    getDraftIdsFromAction(action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): string[];
+    draftActionToSideEffects(queueEntry: DraftAction<CreateContentDocumentAndVersionResourceRequest, ContentDocumentCompositeRepresentation>): Promise<SideEffect[]>;
+    buildCacheKeysFromResponse(response: ContentDocumentCompositeRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngest(response: ContentDocumentCompositeRepresentation, action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): void;
+    mergeRequestBody<T>(): T;
+    ingestResponses(responses: ResponseIngestionEntry[], action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): Promise<void>;
+}

package/dist/types/drafts/contentDocument/draftAwareAdapters/createContentDocumentAndVersion/index.d.ts

@@ -0,0 +1,6 @@
+import type { Luvio } from '@luvio/engine';
+import type { BinaryStore } from '@salesforce/lds-store-binary';
+import type { DraftAwareCreateContentDocumentAndVersionAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { ContentDocumentCompositeRepresentationActionHandler } from '../../ContentDocumentCompositeRepresentationActionHandler';
+import type { DurableRecordStore } from '../../../../durableStore/DurableRecordStore';
+export declare function createContentDocumentAndVersionDraftAdapterFactory(luvio: Luvio, binaryStore: BinaryStore, actionHandler: ContentDocumentCompositeRepresentationActionHandler, durableRecordStore: DurableRecordStore): DraftAwareCreateContentDocumentAndVersionAdapter;

package/dist/types/drafts/index.d.ts

@@ -0,0 +1,14 @@
+export { makeEnvironmentUiApiRecordDraftAware } from './records/environment/makeEnvironmentUiApiRecordDraftAware';
+export { UiApiActionHandler } from './records/actionHandlers/UiApiRecordActionHandler';
+export { UiApiDraftRecordService } from './UiApiDraftRecordService';
+export { QuickActionExecutionRepresentationHandler } from './quickActions/QuickActionExecutionRepresentationHandler';
+export { UpdateRecordQuickActionExecutionRepresentationHandler } from './quickActions/UpdateRecordQuickActionExecutionRepresentationHandler';
+export { createContentDocumentAndVersionDraftAdapterFactory } from './contentDocument/draftAwareAdapters/createContentDocumentAndVersion';
+export { ContentDocumentCompositeRepresentationActionHandler } from './contentDocument/ContentDocumentCompositeRepresentationActionHandler';
+export { createRecordDraftAdapterFactory } from './records/draftAwareAdapters/createRecord';
+export { updateRecordDraftAdapterFactory } from './records/draftAwareAdapters/updateRecord';
+export { deleteRecordDraftAdapterFactory } from './records/draftAwareAdapters/deleteRecord';
+export { performQuickActionDraftAdapterFactory } from './quickActions/draftAwareAdapters/performQuickAction';
+export { performUpdateRecordQuickActionDraftAdapterFactory } from './quickActions/draftAwareAdapters/updateRecordPerformQuickAction';
+export type { DraftRecordRepresentation } from './records/DraftRecordRepresentation';
+export { isCreateContentDocumentAndVersionDraftAdapterEvent } from './contentDocument/draftAwareAdapters/createContentDocumentAndVersion/events';

package/dist/types/drafts/quickActions/QuickActionExecutionRepresentationHandler.d.ts

@@ -0,0 +1,28 @@
+import type { DraftAction, DraftQueue } from '@salesforce/lds-drafts';
+import { AbstractResourceRequestActionHandler } from '../AbstractResourceRequestActionHandler';
+import type { PerformActionInputRepresentation, QuickActionExecutionRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
+import type { UiApiDraftRecordService } from '../UiApiDraftRecordService';
+import type { RecordEffectingHandler } from '../records/actionHandlers/RecordEffectingHandler';
+import { type SideEffectService } from '../sideEffects/SideEffectService';
+import { type SideEffect } from '../sideEffects';
+export declare const QUICK_ACTION_HANDLER = "QUICK_ACTION_HANDLER";
+interface PerformQuickActionResourceRequest extends Omit<ResourceRequest, 'body' | 'method'> {
+    body: PerformActionInputRepresentation;
+    method: 'post';
+}
+export declare class QuickActionExecutionRepresentationHandler extends AbstractResourceRequestActionHandler<QuickActionExecutionRepresentation> implements RecordEffectingHandler {
+    private readonly draftRecordService;
+    readonly isDraftId: (targetId: string) => boolean;
+    private readonly sideEffectService;
+    handlerId: string;
+    constructor(getLuvio: () => Luvio, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, isDraftId: (targetId: string) => boolean, sideEffectService: SideEffectService);
+    draftActionToSideEffects(queueEntry: DraftAction<PerformQuickActionResourceRequest, QuickActionExecutionRepresentation>): Promise<SideEffect[]>;
+    getIdFromRequest(request: ResourceRequest): Promise<string>;
+    getIdFromResponseBody(responseBody: QuickActionExecutionRepresentation): string;
+    buildTagForTargetId(id: string): string;
+    buildCacheKeysFromResponse(_response: QuickActionExecutionRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngest(response: QuickActionExecutionRepresentation): void;
+    mergeRequestBody<T>(): T;
+}
+export {};

package/dist/types/drafts/quickActions/UpdateRecordQuickActionExecutionRepresentationHandler.d.ts

@@ -0,0 +1,29 @@
+import type { CompletedDraftAction, DraftAction, DraftQueue, QueueOperation } from '@salesforce/lds-drafts';
+import { AbstractResourceRequestActionHandler } from '../AbstractResourceRequestActionHandler';
+import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
+import type { PerformActionInputRepresentation, QuickActionExecutionRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { UiApiDraftRecordService } from '../UiApiDraftRecordService';
+import type { RecordEffectingHandler } from '../records/actionHandlers/RecordEffectingHandler';
+import type { SideEffect } from '../sideEffects/sideEffects';
+import { type SideEffectService } from '../sideEffects/SideEffectService';
+export declare const UPDATE_RECORD_QUICK_ACTION_HANDLER = "UPDATE_RECORD_QUICK_ACTION_HANDLER";
+interface PerformUpdateRecordQuickActionResourceRequest extends Omit<ResourceRequest, 'body' | 'method'> {
+    body: PerformActionInputRepresentation;
+    method: 'patch';
+}
+export declare class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractResourceRequestActionHandler<QuickActionExecutionRepresentation> implements RecordEffectingHandler {
+    private readonly draftRecordService;
+    readonly isDraftId: (targetId: string) => boolean;
+    private readonly sideEffectService;
+    handlerId: string;
+    constructor(getLuvio: () => Luvio, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, isDraftId: (targetId: string) => boolean, sideEffectService: SideEffectService);
+    draftActionToSideEffects(queueEntry: DraftAction<PerformUpdateRecordQuickActionResourceRequest, QuickActionExecutionRepresentation>): Promise<SideEffect[]>;
+    getIdFromRequest(request: ResourceRequest): Promise<string>;
+    getIdFromResponseBody(responseBody: QuickActionExecutionRepresentation): string;
+    buildTagForTargetId(id: string): string;
+    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, QuickActionExecutionRepresentation>, _queueOperations: QueueOperation[]): Promise<void>;
+    buildCacheKeysFromResponse(_response: QuickActionExecutionRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngest(response: QuickActionExecutionRepresentation): void;
+    mergeRequestBody<T>(): T;
+}
+export {};

package/dist/types/drafts/quickActions/draftAwareAdapters/performQuickAction.d.ts

@@ -0,0 +1,8 @@
+import type { DraftAwarePerformQuickActionAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { QuickActionExecutionRepresentationHandler } from '../QuickActionExecutionRepresentationHandler';
+/**
+ * @param luvio The runtime's luvio instance
+ * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
+ *        register it with the DraftQueue, runtime should set that up
+ */
+export declare function performQuickActionDraftAdapterFactory(actionHandler: QuickActionExecutionRepresentationHandler, userId: string): DraftAwarePerformQuickActionAdapter;

package/dist/types/drafts/quickActions/draftAwareAdapters/updateRecordPerformQuickAction.d.ts

@@ -0,0 +1,8 @@
+import type { DraftAwarePerformUpdateRecordQuickActionAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { UpdateRecordQuickActionExecutionRepresentationHandler } from '../UpdateRecordQuickActionExecutionRepresentationHandler';
+/**
+ * @param luvio The runtime's luvio instance
+ * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
+ *        register it with the DraftQueue, runtime should set that up
+ */
+export declare function performUpdateRecordQuickActionDraftAdapterFactory(actionHandler: UpdateRecordQuickActionExecutionRepresentationHandler, userId: string): DraftAwarePerformUpdateRecordQuickActionAdapter;

package/dist/types/drafts/records/actionHandlers/RecordEffectingHandler.d.ts

@@ -0,0 +1,6 @@
+import type { DraftAction } from '@salesforce/lds-drafts';
+import { type SideEffect } from '../../sideEffects/sideEffects';
+export interface RecordEffectingHandler {
+    draftActionToSideEffects(queueEntry: DraftAction<unknown, unknown>): Promise<SideEffect[]>;
+    handlerId: string;
+}

package/dist/types/drafts/records/actionHandlers/UiApiRecordActionHandler.d.ts

@@ -0,0 +1,63 @@
+import { type Adapter, type DurableStoreKeyMetadataMap, type Luvio, type NetworkAdapter, type ResourceRequest } from '@luvio/engine';
+import type { GetRecordConfig, RecordRepresentation, RecordInputRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { CompletedDraftAction, DraftAction, DraftActionMetadata, DraftQueue, PendingDraftAction, QueueOperation } from '@salesforce/lds-drafts';
+import type { ObjectInfoService } from '../../utils/types';
+import type { DraftIdAndKeyMapping } from '../../AbstractResourceRequestActionHandler';
+import { AbstractResourceRequestActionHandler } from '../../AbstractResourceRequestActionHandler';
+import type { SideEffect } from '../../sideEffects/sideEffects';
+import type { UiApiDraftRecordService } from '../../UiApiDraftRecordService';
+import type { RecordEffectingHandler } from './RecordEffectingHandler';
+import { type SideEffectService } from '../../sideEffects/SideEffectService';
+import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+export declare const LDS_ACTION_HANDLER_ID = "LDS_ACTION_HANDLER";
+export declare const LDS_ACTION_METADATA_API_NAME = "LDS_ACTION_METADATA_API_NAME";
+export type FormatDisplayValue = (value: boolean | number | string | null, datatype: string) => null | string;
+interface RecordEndpointResourceRequest extends Omit<ResourceRequest, 'body' | 'method'> {
+    body: RecordInputRepresentation;
+    method: 'post' | 'patch' | 'delete';
+}
+export type RecordResourceRequest = RecordEndpointResourceRequest;
+export declare class UiApiActionHandler extends AbstractResourceRequestActionHandler<RecordRepresentation> implements RecordEffectingHandler {
+    protected readonly getLuvio: () => Luvio;
+    protected readonly networkAdapter: NetworkAdapter;
+    protected readonly draftQueue: DraftQueue;
+    private readonly getRecordAdapter;
+    private readonly objectInfoService;
+    readonly isDraftId: (targetId: string) => boolean;
+    protected readonly recordService: UiApiDraftRecordService;
+    private readonly sideEffectService;
+    private readonly durableRecordStore;
+    handlerId: string;
+    constructor(getLuvio: () => Luvio, networkAdapter: NetworkAdapter, draftQueue: DraftQueue, getRecordAdapter: Adapter<GetRecordConfig, RecordRepresentation>, objectInfoService: ObjectInfoService, isDraftId: (targetId: string) => boolean, recordService: UiApiDraftRecordService, sideEffectService: SideEffectService, durableRecordStore: DurableRecordStore);
+    buildPendingAction(request: RecordResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
+    private getBackdatingFields;
+    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, RecordRepresentation>): DraftIdAndKeyMapping[] | undefined;
+    handleActionCompleted(completedAction: CompletedDraftAction<ResourceRequest, RecordRepresentation>, queueOperations: QueueOperation[]): Promise<void>;
+    private fetchReferenceRecord;
+    /**
+     * identify the API Name from the record ID and its field representation. For example, ApiName for `001x0000004cKfzAAE` is `Account` if its field info reference to `Account`
+     * representation
+     * @param id
+     * @param fieldInfo
+     * @returns apiName
+     */
+    private identifyApiName;
+    buildTagForTargetId(id: string): string;
+    getIdFromRequest(request: RecordResourceRequest): Promise<string>;
+    getIdFromResponseBody(responseBody: RecordRepresentation): string;
+    draftActionToSideEffects(action: DraftAction<RecordResourceRequest, RecordRepresentation>): Promise<SideEffect[]>;
+    updateMetadata(existingMetadata: DraftActionMetadata, incomingMetadata: DraftActionMetadata): DraftActionMetadata;
+    private getApiNameForRecordId;
+    /**
+     * Inspects the resource request to ensure this handler can handle it
+     * Inspects the resource request for draft id references. Replaces the draft ids
+     * with their canonical ids if they exist otherwise returns the request as is
+     * @param request The original resource request
+     * @returns the request with draft ids replaced or undefined if this handler is not capable of handling it
+     */
+    private resolveResourceRequest;
+    buildCacheKeysFromResponse(record: RecordRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngest(response: RecordRepresentation): void;
+    mergeRequestBody<T>(targetBody: T, sourceBody: T): T;
+}
+export {};

package/dist/types/drafts/records/draftAwareAdapters/createRecord.d.ts

@@ -0,0 +1,9 @@
+import type { DraftAwareCreateRecordAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
+import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+/**
+ * @param luvio The runtime's luvio instance
+ * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
+ *        register it with the DraftQueue, runtime should set that up
+ */
+export declare function createRecordDraftAdapterFactory(actionHandler: UiApiActionHandler, durableRecordStore: DurableRecordStore): DraftAwareCreateRecordAdapter;

package/dist/types/drafts/records/draftAwareAdapters/updateRecord.d.ts

@@ -0,0 +1,9 @@
+import type { DraftAwareUpdateRecordAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
+import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+/**
+ * @param luvio The runtime's luvio instance
+ * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
+ *        register it with the DraftQueue, runtime should set that up
+ */
+export declare function updateRecordDraftAdapterFactory(actionHandler: UiApiActionHandler, durableRecordStore: DurableRecordStore): DraftAwareUpdateRecordAdapter;

package/dist/types/drafts/records/environment/getRecordDraftEnvironment.d.ts

@@ -0,0 +1,4 @@
+import type { Luvio } from '@luvio/engine';
+import type { DurableEnvironment } from '@luvio/environments';
+import type { DraftEnvironmentOptions } from './makeEnvironmentUiApiRecordDraftAware';
+export declare function getRecordDraftEnvironment(luvio: Luvio, env: DurableEnvironment, { isDraftId, durableRecordStore }: DraftEnvironmentOptions): DurableEnvironment;

package/dist/types/drafts/records/environment/getRecordsDraftEnvironment.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio } from '@luvio/engine';
+import type { DurableEnvironment } from '@luvio/environments';
+import type { DraftEnvironmentOptions } from './makeEnvironmentUiApiRecordDraftAware';
+export declare const RECORDS_ENDPOINT_REGEX: RegExp;
+export declare function getRecordsDraftEnvironment(luvio: Luvio, env: DurableEnvironment, { isDraftId }: DraftEnvironmentOptions): DurableEnvironment;

package/dist/types/drafts/records/environment/makeEnvironmentUiApiRecordDraftAware.d.ts

@@ -0,0 +1,11 @@
+import type { InMemoryStore, Luvio } from '@luvio/engine';
+import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
+import type { DurableEnvironment } from '@luvio/environments';
+import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+export interface DraftEnvironmentOptions {
+    store: InMemoryStore;
+    handler: UiApiActionHandler;
+    durableRecordStore: DurableRecordStore;
+    isDraftId: (id: string) => boolean;
+}
+export declare function makeEnvironmentUiApiRecordDraftAware(luvio: Luvio, options: DraftEnvironmentOptions, env: DurableEnvironment): DurableEnvironment;

package/dist/types/drafts/records/records.d.ts

@@ -0,0 +1,30 @@
+import type { ResourceRequest, Luvio } from '@luvio/engine';
+import type { RecordRepresentation } from '../../adapters/main';
+import type { DraftRecordRepresentation } from './DraftRecordRepresentation';
+export declare const RECORD_ENDPOINT_REGEX: RegExp;
+/**
+ * Extracts a record id from a record ResourceRequest. This method parses out the
+ * recordId from the request path in the case of get, update, and delete.
+ * @param request The ResourceRequest to extract the record id from
+ */
+export declare function getRecordIdFromRecordRequest(request: ResourceRequest): string;
+/**
+ * Gets the store key for the record id that a POST/PATCH/DELETE record request targets
+ * @param resourceRequest
+ */
+export declare function getRecordKeyFromRecordRequest(luvio: Luvio, resourceRequest: ResourceRequest): string | undefined;
+/**
+ * Builds a record store key given its record id
+ * @param recordId record id
+ */
+export declare function getRecordKeyForId(luvio: Luvio, recordId: string): string;
+/**
+ * Drafts are stored with denormalized fields and normalized field links. This method
+ * filters out the field links and returns a flattened record representation.
+ *
+ * Note that reference field links get re-applied during draft record ingestion
+ * @param record draft record representation
+ * @returns flattened record representation
+ */
+export declare function filterOutReferenceNonScalarFields(record: DraftRecordRepresentation): RecordRepresentation;
+export declare function filterOutPrivateProperties(record: RecordRepresentation): Omit<RecordRepresentation, 'eTag' | 'weakEtag'>;

package/dist/types/drafts/sideEffects/SideEffectHandler.d.ts

@@ -0,0 +1,18 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { CreateRecordSideEffect, DeleteRecordSideEffect, FieldIncrementSideEffect, UpdateRecordSideEffect } from './sideEffects';
+export interface SideEffectHandler<EntryType, EffectType> {
+    apply(entry: EntryType | undefined, effect: EffectType): EntryType | undefined;
+}
+export declare class CreateRecordEffectHandler implements SideEffectHandler<DurableRecordRepresentation | undefined, CreateRecordSideEffect> {
+    apply(entry: DurableRecordRepresentation | undefined, effect: CreateRecordSideEffect): DurableRecordRepresentation | undefined;
+}
+export declare class UpdateRecordEffectHandler implements SideEffectHandler<DurableRecordRepresentation, UpdateRecordSideEffect> {
+    apply(record: DurableRecordRepresentation | undefined, effect: UpdateRecordSideEffect): DurableRecordRepresentation | undefined;
+}
+export declare class DeleteRecordEffectHandler implements SideEffectHandler<DurableRecordRepresentation, DeleteRecordSideEffect> {
+    apply(entry: DurableRecordRepresentation | undefined, effect: DeleteRecordSideEffect): DurableRecordRepresentation | undefined;
+}
+export declare class RecordFieldIncrementHandler implements SideEffectHandler<DurableRecordRepresentation, FieldIncrementSideEffect> {
+    private logger;
+    apply(record: DurableRecordRepresentation | undefined, effect: FieldIncrementSideEffect): DurableRecordRepresentation | undefined;
+}

package/dist/types/drafts/sideEffects/SideEffectService.d.ts

@@ -0,0 +1,27 @@
+import type { FormatDisplayValue } from '../records/actionHandlers/UiApiRecordActionHandler';
+import type { ObjectInfoService } from '../utils/types';
+import type { CreateRecordSideEffect, DeleteRecordSideEffect, UpdateRecordSideEffect } from './sideEffects';
+import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+export declare class SideEffectService {
+    private readonly durableRecordStore;
+    private readonly objectInfoService;
+    private readonly userId;
+    private readonly formatDisplayValue;
+    constructor(durableRecordStore: DurableRecordStore, objectInfoService: ObjectInfoService, userId: string, formatDisplayValue: FormatDisplayValue);
+    createRecordCreateSideEffect(recordId: string, draftActionId: string, uniqueId: string, apiName: string, timestamp: number, fields: Record<string, any>): Promise<CreateRecordSideEffect>;
+    createRecordUpdateSideEffect(recordId: string, draftActionId: string, uniqueId: string, apiName: string, timestamp: number, fields: Record<string, any>): Promise<UpdateRecordSideEffect>;
+    createRecordDeleteSideEffect(recordId: string, draftActionId: string, uniqueId: string, apiName: string, timestamp: number): Promise<DeleteRecordSideEffect>;
+    private createSideEffect;
+    private createLink;
+    private synthesizeRecordFromParts;
+    private generateSystemFields;
+    private synthesizeFieldsFromParts;
+    private generateRecordPatch;
+    private getCompoundNameFields;
+    private formatDateTimeField;
+    private ensureObjectInfo;
+    private fillMissingFields;
+    private determineRecordTypeId;
+    private handleReferenceField;
+    private patchIfExists;
+}

package/dist/types/drafts/sideEffects/SideEffectStore.d.ts

@@ -0,0 +1,14 @@
+import type { DurableStore } from '@luvio/environments';
+import type { SideEffect } from './sideEffects';
+export declare class SideEffectStore {
+    private readonly durableStore;
+    private allEffects;
+    private keyToEffectMap;
+    constructor(durableStore: DurableStore);
+    addEffects(effects: SideEffect[]): Promise<void>;
+    removeEffects(effects: SideEffect[]): Promise<void>;
+    getEffects(key: string): SideEffect[];
+    getEffectsByTag(tag: string): SideEffect[];
+    private initialize;
+    private regenerateKeyToEffectMap;
+}