@salesforce/lds-runtime-mobile 0.1.0-dev1

package/sfdc/types/drafts/IdempotentWrite.d.ts

@@ -0,0 +1,33 @@
+import type { HttpStatusCode, Headers } from '@luvio/engine';
+export interface UIApiError {
+    errorCode: string;
+    message: string | null;
+}
+export declare const enum IdempotentWriteSpecificHttpStatusCode {
+    RequestTimeout = 408,
+    Conflict = 409,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    UnProcessableEntity = 422
+}
+/**
+ * The http status code which could be returned from idempotent write.
+ */
+export type IdempotentWriteHttpStatusCode = IdempotentWriteSpecificHttpStatusCode | HttpStatusCode;
+export declare const HTTP_HEADER_RETRY_AFTER = "Retry-After";
+export declare const HTTP_HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
+export declare const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = "IDEMPOTENCY_FEATURE_NOT_ENABLED";
+export declare const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = "IDEMPOTENCY_NOT_SUPPORTED";
+export declare const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = "IDEMPOTENCY_KEY_USED_DIFFERENT_USER";
+export declare const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = "IDEMPOTENCY_CONCURRENT_REQUEST";
+export declare const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = "IDEMPOTENCY_KEY_ALREADY_USED";
+export declare const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = "IDEMPOTENCY_BACKEND_OPERATION_ERROR";
+/**
+ * Get the retry after in milliseconds from the response headers, undefined if not specified.
+ * The header could have two different format.
+ * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
+ * Retry-After: <delay-seconds>, like 1.5s
+ * @param headers http headers
+ * @returns the time to delat in millisconds.
+ */
+export declare function getRetryAfterInMs(headers?: Headers): number | undefined;

package/sfdc/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/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/sfdc/types/drafts/contentDocument/draftAwareAdapters/createContentDocumentAndVersion/events.d.ts

@@ -0,0 +1,30 @@
+import type { CustomAdapterEvent } from '@luvio/engine';
+export declare const CONTENT_DOCUMENT_AND_VERSION_NAMESPACE = "create-content-document-and-version-draft";
+interface CreateContentDocumentAndVersionStartEvent {
+    type: 'create-content-document-and-version-draft-start';
+}
+interface CreateContentDocumentAndVersionFinishedEvent {
+    type: 'create-content-document-and-version-draft-finished';
+}
+interface CreateContentDocumentAndVersionConvertToFileReferenceEvent {
+    type: 'create-content-document-and-version-convert-to-file-reference';
+    handle: string;
+}
+interface CreateContentDocumentAndVersionSynthesizeStartEvent {
+    type: 'create-content-document-and-version-synthesize-response-start';
+    handle: string;
+    mimeType: string;
+}
+interface CreateContentDocumentAndVersionSynthesizeErrorEvent {
+    type: 'create-content-document-and-version-synthesized-response-error';
+    handle: string;
+    mimeType: string;
+    error: unknown;
+}
+interface CreateContentDocumentAndVersionSynthesizeSuccessEvent {
+    type: 'create-content-document-and-version-synthesized-response-success';
+    handle: string;
+}
+export type CreateContentDocumentAndVersionDraftAdapterEvent = CreateContentDocumentAndVersionStartEvent | CreateContentDocumentAndVersionFinishedEvent | CreateContentDocumentAndVersionConvertToFileReferenceEvent | CreateContentDocumentAndVersionSynthesizeSuccessEvent | CreateContentDocumentAndVersionSynthesizeStartEvent | CreateContentDocumentAndVersionSynthesizeErrorEvent;
+export declare function isCreateContentDocumentAndVersionDraftAdapterEvent(customEvent: CustomAdapterEvent<unknown>): customEvent is CustomAdapterEvent<CreateContentDocumentAndVersionDraftAdapterEvent>;
+export {};

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

@@ -0,0 +1,10 @@
+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 interface FileLike {
+    size: number;
+    slice(start: number, end: number, contentType?: string): Blob;
+}
+export declare function createContentDocumentAndVersionDraftAdapterFactory(luvio: Luvio, binaryStore: BinaryStore, actionHandler: ContentDocumentCompositeRepresentationActionHandler, durableRecordStore: DurableRecordStore): DraftAwareCreateContentDocumentAndVersionAdapter;

package/sfdc/types/drafts/contentDocument/shared.d.ts

@@ -0,0 +1,6 @@
+export declare const CONTENT_DOCUMENT_DRAFT_ID_KEY = "CONTENT_DOCUMENT_DRAFT_ID";
+export declare const CONTENT_VERSION_DRAFT_ID_KEY = "CONTENT_VERSION_DRAFT_ID";
+export declare const CONTENT_DOCUMENT_LINK_DRAFT_ID_KEY = "CONTENT_DOCUMENT_LINK_DRAFT_ID";
+export declare const RESPONSE_CONTENT_DOCUMENT_FIELDS: string[];
+export declare const RESPONSE_CONTENT_DOCUMENT_LINK_FIELDS: string[];
+export declare const RESPONSE_CONTENT_VERSION_FIELDS: string[];

package/sfdc/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/sfdc/types/drafts/quickActions/AbstractQuickActionHandler.d.ts

@@ -0,0 +1,11 @@
+import { AbstractResourceRequestActionHandler } from '../AbstractResourceRequestActionHandler';
+import { QuickActionExecutionRepresentation } from '@salesforce/lds-adapters-uiapi';
+import { NetworkAdapter, ResourceRequest } from '@luvio/engine';
+import { DraftAction, DraftQueue, PendingDraftAction } from '@salesforce/lds-drafts';
+import { Luvio } from '@luvio/engine';
+import { UiApiDraftRecordService } from '../UiApiDraftRecordService';
+export declare abstract class AbstractQuickActionHandler extends AbstractResourceRequestActionHandler<QuickActionExecutionRepresentation> {
+    constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio, recordService: UiApiDraftRecordService);
+    buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
+    private resolveResourceRequestBody;
+}

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

@@ -0,0 +1,36 @@
+import type { CompletedDraftAction, QueueOperation, DraftAction, DraftQueue } from '@salesforce/lds-drafts';
+import { AbstractQuickActionHandler } from './AbstractQuickActionHandler';
+import type { PerformActionInputRepresentation, QuickActionExecutionRepresentation, RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+import { GetRecordConfig } from '@salesforce/lds-adapters-uiapi';
+import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest, Adapter } 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';
+import { ObjectInfoService } from './../../utils/ObjectInfoService';
+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 AbstractQuickActionHandler implements RecordEffectingHandler {
+    private readonly draftRecordService;
+    readonly isDraftId: (targetId: string) => boolean;
+    private readonly sideEffectService;
+    private readonly objectInfoService;
+    private readonly getRecord;
+    handlerId: string;
+    private readonly instrumentation;
+    constructor(getLuvio: () => Luvio, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, isDraftId: (targetId: string) => boolean, sideEffectService: SideEffectService, objectInfoService: ObjectInfoService, getRecord: Adapter<GetRecordConfig, RecordRepresentation>);
+    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;
+    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, QuickActionExecutionRepresentation>, queueOperations: QueueOperation[]): Promise<void>;
+    private fetchRecordIntoStoreFromCompletedAction;
+    private allFields;
+    mergeRequestBody<T>(): T;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import type { CompletedDraftAction, DraftAction, DraftQueue, QueueOperation } from '@salesforce/lds-drafts';
+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';
+import { AbstractQuickActionHandler } from './AbstractQuickActionHandler';
+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 AbstractQuickActionHandler 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/sfdc/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/sfdc/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/sfdc/types/drafts/records/DraftRecordRepresentation.d.ts

@@ -0,0 +1,15 @@
+import { type DurableRecordRepresentation, type ScalarFieldType } from '@salesforce/lds-durable-records';
+/**
+ * Luvio normalizes all record fields regardless of if they are scalar or record references. This does not
+ * lend itself well to draft application. When dealing we drafts we convert this fully normalized record into
+ * a partially normalized record where all scalar fields are denormalized back into the parent record while
+ * record references remain normalized as links.
+ *
+ * Note that this is also the format that records get stored in in the durable store
+ */
+export type DraftRecordRepresentation = Omit<DurableRecordRepresentation, 'links'>;
+export type DraftRepresentation = DraftRecordRepresentation['drafts'];
+export type DraftRecordFieldValueRepresentation = DraftRecordRepresentation['fields'][string];
+export { ScalarFieldType };
+export declare function isFieldLink(field: DraftRecordFieldValueRepresentation): boolean;
+export declare function isPendingOrMissing(field: DraftRecordFieldValueRepresentation): boolean;

package/sfdc/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/sfdc/types/drafts/records/actionHandlers/SideEffectHook.d.ts

@@ -0,0 +1,19 @@
+import type { SideEffect } from '../../sideEffects';
+interface BaseSideEffectHook {
+    on: 'post' | 'patch' | 'delete';
+    apiName: string;
+}
+export interface CreateSideEffectHook extends BaseSideEffectHook {
+    on: 'post';
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>): Promise<SideEffect[]>;
+}
+export interface UpdateSideEffectHook extends BaseSideEffectHook {
+    on: 'patch';
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>): Promise<SideEffect[]>;
+}
+export interface DeleteSideEffectHook extends BaseSideEffectHook {
+    on: 'delete';
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string): Promise<SideEffect[]>;
+}
+export type SideEffectHook = CreateSideEffectHook | UpdateSideEffectHook | DeleteSideEffectHook;
+export {};

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

@@ -0,0 +1,66 @@
+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 { SideEffectHook } from './SideEffectHook';
+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;
+    private sideEffectHooks;
+    constructor(getLuvio: () => Luvio, networkAdapter: NetworkAdapter, draftQueue: DraftQueue, getRecordAdapter: Adapter<GetRecordConfig, RecordRepresentation>, objectInfoService: ObjectInfoService, isDraftId: (targetId: string) => boolean, recordService: UiApiDraftRecordService, sideEffectService: SideEffectService, durableRecordStore: DurableRecordStore);
+    setSideEffectHooks(hooks: SideEffectHook[]): void;
+    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/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/sfdc/types/drafts/records/draftAwareAdapters/deleteRecord.d.ts

@@ -0,0 +1,8 @@
+import type { DraftAwareDeleteRecordAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
+/**
+ * @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 deleteRecordDraftAdapterFactory(actionHandler: UiApiActionHandler): DraftAwareDeleteRecordAdapter;

package/sfdc/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/sfdc/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/sfdc/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/sfdc/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/sfdc/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/sfdc/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/sfdc/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/sfdc/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;
+}

package/sfdc/types/drafts/sideEffects/index.d.ts

@@ -0,0 +1,2 @@
+export { SideEffectStore } from './SideEffectStore';
+export type { SideEffect } from './sideEffects';

package/sfdc/types/drafts/sideEffects/sideEffectEnvironment.d.ts

@@ -0,0 +1,3 @@
+import type { DurableEnvironment } from '@luvio/environments';
+import type { SideEffectStore } from './SideEffectStore';
+export declare function enableSideEffectsOnEnvironment(env: DurableEnvironment, sideEffectStore: SideEffectStore): DurableEnvironment;

package/sfdc/types/drafts/sideEffects/sideEffects.d.ts

@@ -0,0 +1,36 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+interface BaseRecordSideEffect {
+    key: string;
+    tag: string;
+    uniqueId: string;
+    timestamp: number;
+}
+export interface CreateRecordSideEffect extends BaseRecordSideEffect {
+    type: 'record-create';
+    record: DurableRecordRepresentation;
+}
+export interface UpdateRecordSideEffect extends BaseRecordSideEffect {
+    type: 'record-update';
+    recordPatch: Partial<DurableRecordRepresentation>;
+}
+export interface DeleteRecordSideEffect extends BaseRecordSideEffect {
+    type: 'record-delete';
+}
+export interface FieldIncrementSideEffect extends BaseRecordSideEffect {
+    type: 'record-field-increment';
+    fieldName: string;
+    value: number;
+}
+export type SideEffect = CreateRecordSideEffect | UpdateRecordSideEffect | DeleteRecordSideEffect | FieldIncrementSideEffect;
+/**
+ * Removes any existing effects on a record and re-applies the given ordered list and returns the record
+ * with the updated side effects applied.
+ *
+ * If the record contains effects applied to it and we no longer
+ * have any effects to apply to it, they will be removed and the result returned without any side effect applied
+ *
+ * @param record The base record to apply effects to to. If undefined the first effect must be a record-create operation
+ * @param sideEffects The list of effects to apply to the record
+ */
+export declare function resetAndApplyEffects(record: DurableRecordRepresentation | undefined, sideEffects: SideEffect[]): DurableRecordRepresentation | undefined;
+export {};

package/sfdc/types/drafts/utils/adapter.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from '@luvio/engine';
+export declare function getAdapterData<Config, Data>(adapter: Adapter<Config, Data>, config: Config): Promise<Data | undefined>;

package/sfdc/types/drafts/utils/clone.d.ts

@@ -0,0 +1 @@
+export declare function clone<T>(obj: T): T;