@salesforce/lds-runtime-mobile 1.318.0 → 1.320.0

package/dist/types/NimbusDraftQueue.d.ts

@@ -20,7 +20,7 @@ export declare class NimbusDraftQueue implements DraftQueue {
     mergeActions<Data, Response>(_targetActionId: string, _sourceActionId: string): Promise<DraftAction<Data, Response>>;
     retryAction<Data, Response>(_actionId: string): Promise<DraftAction<Data, Response>>;
     setMetadata(_actionId: string, _metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
-    addHandler(_handler: ActionHandler<unknown, unknown, unknown>): Promise<void>;
+    addHandler(_handler: ActionHandler<unknown, unknown>): Promise<void>;
     addCustomHandler(_id: string, _executor: CustomActionExecutor): Promise<void>;
     removeHandler(_id: string): Promise<void>;
     updateDraftAction<Data, Response>(_action: DraftAction<Data, Response>): Promise<void>;

package/dist/types/{draftsAdapters → drafts}/AbstractResourceRequestActionHandler.d.ts

@@ -1,49 +1,51 @@
 import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
-import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue } from '@salesforce/lds-drafts';
+import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue, ActionHandler } from '@salesforce/lds-drafts';
 import { ProcessActionResult } from '@salesforce/lds-drafts';
-import type { ActionHandler, DraftIdAndKeyMapping } from '@salesforce/lds-drafts';
+import type { UiApiDraftRecordService } from './UiApiDraftRecordService';
 export type ResponseIngestionEntry<T = unknown> = {
     response: T;
-    synchronousIngest: AbstractResourceRequestActionHandler<T, unknown>['synchronousIngest'];
-    buildCacheKeysForResponse: AbstractResourceRequestActionHandler<T, unknown>['buildCacheKeysFromResponse'];
+    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, DraftMetadata> implements ActionHandler<ResourceRequest, DraftMetadata, ResponseType> {
+export declare abstract class AbstractResourceRequestActionHandler<ResponseType> implements ActionHandler<ResourceRequest, ResponseType> {
     protected readonly draftQueue: DraftQueue;
     protected readonly networkAdapter: NetworkAdapter;
     protected readonly getLuvio: () => Luvio;
-    ephemeralRedirects: {
-        [key: string]: string;
-    };
+    protected readonly recordService: UiApiDraftRecordService;
     isIdempotencySupported: boolean;
     isLdsIdempotencyWriteDisabled: boolean;
     isBackdatingEnabled: boolean;
-    constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio);
+    constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio, recordService: UiApiDraftRecordService);
     enqueue(data: ResourceRequest): 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>;
-    handleIdempotencyServerError(responseBody: any, action: DraftAction<ResourceRequest, ResponseType>, updateIdempotencyKey: boolean, ...targetErrorCodes: string[]): boolean;
-    isUiApiErrors(body: any): boolean;
-    isBackdatingError(body: any, action: DraftAction<ResourceRequest, ResponseType>): any;
     buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
-    handleActionEnqueued(_action: PendingDraftAction<ResourceRequest>): Promise<void>;
+    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;
-    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, ResponseType>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
     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;
-    protected reingestRecord(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    private handleIdempotencyServerError;
+    private isUiApiErrors;
+    private isBackdatingError;
     getDraftIdsFromAction(action: DraftAction<ResourceRequest, ResponseType>): string[];
     hasIdempotencySupport(): boolean;
-    ingestResponses(responses: ResponseIngestionEntry[], action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    protected ingestResponses(responses: ResponseIngestionEntry[], action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
     evictKey(key: string): Promise<void>;
     abstract handlerId: string;
-    abstract canHandlePublish(key: string): boolean;
-    abstract canRepresentationContainDraftMetadata(representationName: string): boolean;
     /**
      * Extracts or synthesizes an id from a given resource request
      * @throws if the id cannot be determined or synthesized
@@ -54,9 +56,6 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType,
     abstract buildTagForTargetId(id: string): string;
     abstract buildCacheKeysFromResponse(response: ResponseType): DurableStoreKeyMetadataMap;
     abstract synchronousIngest(response: ResponseType, action: DraftAction<ResourceRequest, ResponseType>): void;
-    abstract getDataForAction(action: DraftAction<ResourceRequest, ResponseType>): Promise<ResponseType | undefined>;
-    abstract getDraftMetadata(key: string): Promise<DraftMetadata | undefined>;
-    abstract applyDraftsToIncomingData(key: string, data: unknown, draftMetadata: DraftMetadata | undefined, publishFn: (key: string, data: any) => void): void;
     /**
      * Returns true if the given targetId is a for a draft-created record
      *

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/{sfdc/types/draftsAdapters/ContentDocumentCompositeRepresentation → dist/types/drafts/contentDocument}/ContentDocumentCompositeRepresentationActionHandler.d.ts

@@ -1,33 +1,37 @@
 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, DraftIdAndKeyMapping } from '@salesforce/lds-drafts';
-import type { RecordEffectingHandler } from '../RecordRepresentation/actionHandlers/RecordEffectingHandler';
-import type { DraftRecordOperation, RecordDraftMetadata } from '../RecordRepresentation/replayDraftsOnRecord';
+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, CreateContentDocumentAndVersionResourceRequestConfig, ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+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, RecordDraftMetadata> implements RecordEffectingHandler {
+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, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, isDraftId: (targetId: string) => boolean, binaryStore: BinaryStore);
+    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;
     }[];
-    canHandlePublish(_key: string): boolean;
-    canRepresentationContainDraftMetadata(_representationName: string): boolean;
     getIdFromRequest(_request: ResourceRequest): Promise<string>;
     getIdFromResponseBody(responseBody: ContentDocumentCompositeRepresentation): string;
     buildTagForTargetId(id: string): string;
@@ -36,14 +40,10 @@ export declare class ContentDocumentCompositeRepresentationActionHandler extends
         contentVersionId: string;
         contentDocumentLinkId: string;
     };
-    getDataForAction(action: DraftAction<CreateContentDocumentAndVersionResourceRequest, ContentDocumentCompositeRepresentation>): Promise<ContentDocumentCompositeRepresentation | undefined>;
-    handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;
     handleActionRemoved(action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): Promise<void>;
     getRedirectMappings(action: CompletedDraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): DraftIdAndKeyMapping[] | undefined;
-    getDraftMetadata(_key: string): Promise<RecordDraftMetadata | undefined>;
-    applyDraftsToIncomingData(key: string, data: unknown, _draftMetadata: any, publishFn: (key: string, data: any) => void): void;
     getDraftIdsFromAction(action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): string[];
-    draftActionToDraftOperation(queueEntry: DraftAction<CreateContentDocumentAndVersionResourceRequest, ContentDocumentCompositeRepresentation>): DraftRecordOperation[] | undefined;
+    draftActionToSideEffects(queueEntry: DraftAction<CreateContentDocumentAndVersionResourceRequest, ContentDocumentCompositeRepresentation>): Promise<SideEffect[]>;
     buildCacheKeysFromResponse(response: ContentDocumentCompositeRepresentation): DurableStoreKeyMetadataMap;
     synchronousIngest(response: ContentDocumentCompositeRepresentation, action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): void;
     mergeRequestBody<T>(): T;

package/{sfdc/types/draftsAdapters/ContentDocumentCompositeRepresentation → dist/types/drafts/contentDocument}/draftAwareAdapters/createContentDocumentAndVersion/index.d.ts

@@ -2,5 +2,5 @@ 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 { DurableStore } from '@luvio/environments';
-export declare function createContentDocumentAndVersionDraftAdapterFactory(luvio: Luvio, binaryStore: BinaryStore, actionHandler: ContentDocumentCompositeRepresentationActionHandler, durableStore: DurableStore): DraftAwareCreateContentDocumentAndVersionAdapter;
+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/{draftsAdapters/QuickActionExecutionRepresentation → drafts/quickActions}/QuickActionExecutionRepresentationHandler.d.ts

@@ -1,31 +1,26 @@
-import type { DraftAction, DraftQueue, PendingDraftAction } from '@salesforce/lds-drafts';
+import type { DraftAction, DraftQueue } from '@salesforce/lds-drafts';
 import { AbstractResourceRequestActionHandler } from '../AbstractResourceRequestActionHandler';
 import type { PerformActionInputRepresentation, QuickActionExecutionRepresentation } from '../../adapters/main';
 import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
 import type { UiApiDraftRecordService } from '../UiApiDraftRecordService';
-import type { RecordEffectingHandler } from '../RecordRepresentation/actionHandlers/RecordEffectingHandler';
-import type { DraftRecordOperation } from '../RecordRepresentation/replayDraftsOnRecord';
+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 {
+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);
-    draftActionToDraftOperation(queueEntry: DraftAction<PerformQuickActionResourceRequest, QuickActionExecutionRepresentation>): DraftRecordOperation[] | undefined;
-    handleActionEnqueued(action: PendingDraftAction<PerformQuickActionResourceRequest>): Promise<void>;
-    canHandlePublish(_key: string): boolean;
-    canRepresentationContainDraftMetadata(_representationName: string): boolean;
+    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;
-    getDataForAction(action: DraftAction<ResourceRequest, QuickActionExecutionRepresentation>): Promise<QuickActionExecutionRepresentation | undefined>;
-    getDraftMetadata(_key: string): Promise<{} | undefined>;
-    applyDraftsToIncomingData(key: string, data: unknown, _draftMetadata: {} | undefined, publishFn: (key: string, data: any) => void): void;
-    handleActionRemoved(action: DraftAction<ResourceRequest, QuickActionExecutionRepresentation>): Promise<void>;
     buildCacheKeysFromResponse(_response: QuickActionExecutionRepresentation): DurableStoreKeyMetadataMap;
     synchronousIngest(response: QuickActionExecutionRepresentation): void;
     mergeRequestBody<T>(): T;

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 '../../adapters/main';
+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/{draftsAdapters/QuickActionExecutionRepresentation → drafts/quickActions}/draftAwareAdapters/performQuickAction.d.ts

@@ -5,4 +5,4 @@ import type { QuickActionExecutionRepresentationHandler } from '../QuickActionEx
  * @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): DraftAwarePerformQuickActionAdapter;
+export declare function performQuickActionDraftAdapterFactory(actionHandler: QuickActionExecutionRepresentationHandler, userId: string): DraftAwarePerformQuickActionAdapter;

package/{sfdc/types/draftsAdapters/QuickActionExecutionRepresentation → dist/types/drafts/quickActions}/draftAwareAdapters/updateRecordPerformQuickAction.d.ts

@@ -5,4 +5,4 @@ import type { UpdateRecordQuickActionExecutionRepresentationHandler } from '../U
  * @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): DraftAwarePerformUpdateRecordQuickActionAdapter;
+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/{sfdc/types/draftsAdapters/RecordRepresentation → dist/types/drafts/records}/draftAwareAdapters/createRecord.d.ts

@@ -1,9 +1,9 @@
 import type { DraftAwareCreateRecordAdapter } from '@salesforce/lds-adapters-uiapi';
 import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
-import type { DurableStore } from '@luvio/environments';
+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, durableStore: DurableStore): DraftAwareCreateRecordAdapter;
+export declare function createRecordDraftAdapterFactory(actionHandler: UiApiActionHandler, durableRecordStore: DurableRecordStore): DraftAwareCreateRecordAdapter;

package/{sfdc/types/draftsAdapters/RecordRepresentation → dist/types/drafts/records}/draftAwareAdapters/updateRecord.d.ts

@@ -1,9 +1,9 @@
 import type { DraftAwareUpdateRecordAdapter } from '@salesforce/lds-adapters-uiapi';
 import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
-import type { DurableStore } from '@luvio/environments';
+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, durableStore: DurableStore): DraftAwareUpdateRecordAdapter;
+export declare function updateRecordDraftAdapterFactory(actionHandler: UiApiActionHandler, durableRecordStore: DurableRecordStore): DraftAwareUpdateRecordAdapter;

package/dist/types/{draftsAdapters/RecordRepresentation → drafts/records}/environment/getRecordDraftEnvironment.d.ts

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

package/dist/types/{draftsAdapters/RecordRepresentation → drafts/records}/environment/getRecordsDraftEnvironment.d.ts

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

package/{sfdc/types/draftsAdapters/RecordRepresentation → dist/types/drafts/records}/environment/makeEnvironmentUiApiRecordDraftAware.d.ts

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

package/{sfdc/types/draftsAdapters/RecordRepresentation → dist/types/drafts/records}/records.d.ts

@@ -1,5 +1,5 @@
 import type { ResourceRequest, Luvio } from '@luvio/engine';
-import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { RecordRepresentation } from '../../adapters/main';
 import type { DraftRecordRepresentation } from './DraftRecordRepresentation';
 export declare const RECORD_ENDPOINT_REGEX: RegExp;
 /**

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

@@ -0,0 +1,14 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { CreateRecordSideEffect, DeleteRecordSideEffect, 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;
+}

package/dist/types/{sideEffects → drafts/sideEffects}/SideEffectService.d.ts

@@ -1,16 +1,16 @@
-import { type DurableStore } from '@luvio/environments';
-import type { FormatDisplayValue } from '../draftsAdapters/RecordRepresentation/actionHandlers/UiApiRecordActionHandler';
-import type { ObjectInfoService } from '../utils/ObjectInfoService';
+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 durableStore;
+    private readonly durableRecordStore;
     private readonly objectInfoService;
     private readonly userId;
     private readonly formatDisplayValue;
-    constructor(durableStore: DurableStore, objectInfoService: ObjectInfoService, userId: string, formatDisplayValue: 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, fields: Record<string, any>): Promise<DeleteRecordSideEffect>;
+    createRecordDeleteSideEffect(recordId: string, draftActionId: string, uniqueId: string, apiName: string, timestamp: number): Promise<DeleteRecordSideEffect>;
     private createSideEffect;
     private createLink;
     private synthesizeRecordFromParts;

package/dist/types/drafts/utils/durableStore.d.ts

@@ -0,0 +1,3 @@
+import type { DurableRecordRepresentationField } from '@salesforce/lds-durable-records';
+export declare function isDraftFieldPending(field: DurableRecordRepresentationField): boolean;
+export declare function isDraftFieldMissing(field: DurableRecordRepresentationField): boolean;

package/dist/types/durableStore/DurableRecordStore.d.ts

@@ -0,0 +1,17 @@
+import { type DurableStore } from '@luvio/environments';
+import type { Luvio, StoreMetadata } from '@luvio/engine';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+export declare class DurableRecordStore {
+    private readonly durableStore;
+    private readonly getLuvio;
+    constructor(durableStore: DurableStore & SqliteStore, getLuvio: () => Luvio);
+    exists(key: string): Promise<boolean>;
+    getRecord(key: string): Promise<DurableRecordRepresentation | undefined>;
+    getRecords(keys: string[]): Promise<Map<string, DurableRecordRepresentation>>;
+    getRecordsWithMetadata(keys: string[]): Promise<Map<string, {
+        record: DurableRecordRepresentation;
+        metadata: StoreMetadata | undefined;
+    }>>;
+    private entriesToRecordDirectory;
+}

package/dist/types/durableStore/NimbusSqliteStore/tables/index.d.ts

@@ -1,2 +1 @@
 export { LdsDraftsDataTable } from './LdsDraftsDataTable';
-export { LdsDraftIdMapDataTable } from './LdsDraftIdMapDataTable';

package/dist/types/graphql/adapter/draftAwareGraphQLAdapterFactory.d.ts

@@ -0,0 +1,6 @@
+import type { Luvio, Snapshot, StoreLookup, CoercedAdapterRequestContext } from '@luvio/engine';
+import type { DraftAwareGraphQLAdapter, GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+import type { DraftFunctions, ObjectInfoService } from '../types';
+export declare const replaceDraftIdsInVariables: (variables: Record<string, any>, draftFunctions: DraftFunctions, unmappedDraftIDs: Set<string>) => Record<string, any>;
+export declare function draftAwareGraphQLAdapterFactory(userId: string, objectInfoService: ObjectInfoService, store: SqliteStore, luvio: Luvio, isDraftId: (id: string) => boolean, buildCachedSnapshotCachePolicy: (context: any, storeLookup: StoreLookup<GraphQLRepresentation, unknown>) => Snapshot<GraphQLRepresentation, any>, buildNetworkSnapshotCachePolicy: (context: any, coercedAdapterRequestContext: CoercedAdapterRequestContext) => Promise<Snapshot<GraphQLRepresentation, any>>): DraftAwareGraphQLAdapter;

package/dist/types/graphql/adapter/environmentAwareGraphQLBatchAdapterFactory.d.ts

@@ -0,0 +1,4 @@
+import type { CoercedAdapterRequestContext, Luvio, Snapshot, StoreLookup } from '@luvio/engine';
+import type { GraphQLBatchRepresentation, EnvironmentAwareGraphQLBatchAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { ObjectInfoService } from '../types';
+export declare function environmentAwareGraphQLBatchAdapterFactory(objectInfoService: ObjectInfoService, luvio: Luvio, isDraftId: (id: string) => boolean, buildCachedSnapshotCachePolicy: (context: any, storeLookup: StoreLookup<GraphQLBatchRepresentation, unknown>) => Snapshot<GraphQLBatchRepresentation, any>, buildNetworkSnapshotCachePolicy: (context: any, coercedAdapterRequestContext: CoercedAdapterRequestContext) => Promise<Snapshot<GraphQLBatchRepresentation, any>>): EnvironmentAwareGraphQLBatchAdapter;

package/dist/types/graphql/adapter/graphqlEvalAdapterFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio } from '@luvio/engine';
+import type { DraftAwareGraphQLAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+import type { ObjectInfoService } from '../types';
+export declare function graphqlEvalAdapterFactory(_userId: string, _objectInfoService: ObjectInfoService, _store: SqliteStore, _luvio: Luvio, _isDraftId: (id: string) => boolean): DraftAwareGraphQLAdapter;

package/dist/types/graphql/adapter/utils.d.ts

@@ -0,0 +1,2 @@
+import type { Luvio } from '@luvio/engine';
+export declare function getCanonicalIdFunction(luvio: Luvio): (id: string) => string;

package/dist/types/graphql/adapterFactory.d.ts

@@ -0,0 +1,3 @@
+export { draftAwareGraphQLAdapterFactory } from './adapter/draftAwareGraphQLAdapterFactory';
+export { environmentAwareGraphQLBatchAdapterFactory } from './adapter/environmentAwareGraphQLBatchAdapterFactory';
+export { graphqlEvalAdapterFactory } from './adapter/graphqlEvalAdapterFactory';

package/dist/types/graphql/array.d.ts

@@ -0,0 +1,2 @@
+export declare function removeUndefined<T>(array: T[]): NonNullable<T>[];
+export declare function flat(arr: any[], d?: number): any[];

package/dist/types/graphql/base64.d.ts

@@ -0,0 +1,4 @@
+export declare function btoaPolyfill(input: string): string;
+export declare function atobPolyfill(data: string): string;
+export declare const base64encode: (data: string) => string;
+export declare const base64decode: (data: string) => string;

package/dist/types/graphql/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const JSON_EXTRACT_PATH_INGESTION_TIMESTAMP = "$.ingestionTimestamp";
+export declare const JSON_EXTRACT_PATH_INGESTION_APINAME = "$.apiName";
+export declare const JSON_EXTRACT_PATH_DRAFTS = "$.drafts";

package/dist/types/graphql/context.d.ts

@@ -0,0 +1,19 @@
+import type { AvailableSnapshot } from '@luvio/engine';
+import type { GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteResult, SqliteStore, SqliteType } from '@salesforce/lds-store-sql';
+import type { DataLoader } from './dataloader';
+import type { DraftFunctions, LocalEvaluationRuntimeSettings, ObjectInfoMap, RecordRepresentation } from './types';
+export type QueryFunction = (sql: string, params: SqliteType[]) => Promise<SqliteResult>;
+export type ResolverContext = {
+    query: QueryFunction;
+    objectInfos: ObjectInfoMap;
+    eventEmitter: (eventData: unknown) => void;
+    settings: LocalEvaluationRuntimeSettings;
+    Record: DataLoader<string, RecordRepresentation>;
+    snapshot: AvailableSnapshot<GraphQLRepresentation>;
+    seenRecordIds: Set<string>;
+    possibleStaleRecordMap: Map<string, string[]>;
+    draftFunctions?: DraftFunctions;
+    mappedCursors: Map<string, string>;
+};
+export declare function createContext(store: SqliteStore, objectInfos: ObjectInfoMap, eventEmitter: (eventData: unknown) => void, settings: LocalEvaluationRuntimeSettings, snapshot: AvailableSnapshot<GraphQLRepresentation>, mappedCursors?: Map<string, string>, draftFunctions?: DraftFunctions): ResolverContext;