@salesforce/lds-runtime-mobile 1.314.0 → 1.316.0

package/dist/types/draftsAdapters/ContentDocumentCompositeRepresentation/ContentDocumentCompositeRepresentationActionHandler.d.ts

@@ -0,0 +1,51 @@
+import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
+import { AbstractResourceRequestActionHandler } from '@salesforce/lds-drafts';
+import type { ResponseIngestionEntry, 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 { UiApiDraftRecordService } from '../UiApiDraftRecordService';
+import type { ContentDocumentCompositeRepresentation, CreateContentDocumentAndVersionResourceRequestConfig, ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { BinaryStore } from '@salesforce/lds-store-binary';
+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 {
+    protected readonly getLuvio: () => Luvio;
+    private readonly draftRecordService;
+    protected readonly draftQueue: DraftQueue;
+    protected readonly networkAdapter: NetworkAdapter;
+    readonly isDraftId: (targetId: string) => boolean;
+    private readonly binaryStore;
+    private binaryStoreUrlsToUpdate;
+    handlerId: string;
+    constructor(getLuvio: () => Luvio, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, isDraftId: (targetId: string) => boolean, binaryStore: BinaryStore);
+    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;
+    getIdsFromAction(action: DraftAction<ResourceRequest, ContentDocumentCompositeRepresentation>): {
+        contentDocumentId: string;
+        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;
+    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/draftsAdapters/ContentDocumentCompositeRepresentation/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/dist/types/draftsAdapters/ContentDocumentCompositeRepresentation/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 { DurableStore } from '@luvio/environments';
+export declare function createContentDocumentAndVersionDraftAdapterFactory(luvio: Luvio, binaryStore: BinaryStore, actionHandler: ContentDocumentCompositeRepresentationActionHandler, durableStore: DurableStore): DraftAwareCreateContentDocumentAndVersionAdapter;

package/dist/types/draftsAdapters/ContentDocumentCompositeRepresentation/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/dist/types/draftsAdapters/QuickActionExecutionRepresentation/QuickActionExecutionRepresentationHandler.d.ts

@@ -0,0 +1,33 @@
+import type { DraftAction, DraftQueue, PendingDraftAction } from '@salesforce/lds-drafts';
+import { AbstractResourceRequestActionHandler } from '@salesforce/lds-drafts';
+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';
+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;
+    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;
+    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;
+}
+export {};

package/dist/types/draftsAdapters/QuickActionExecutionRepresentation/UpdateRecordQuickActionExecutionRepresentationHandler.d.ts

@@ -0,0 +1,38 @@
+import type { ActionHandler, CompletedDraftAction, DraftAction, DraftQueue, PendingDraftAction, QueueOperation } from '@salesforce/lds-drafts';
+import { AbstractResourceRequestActionHandler } from '@salesforce/lds-drafts';
+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 '../RecordRepresentation/actionHandlers/RecordEffectingHandler';
+import type { DraftRecordOperation, RecordDraftMetadata } from '../RecordRepresentation/replayDraftsOnRecord';
+import { type DurableStore } from '@luvio/environments';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+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;
+    private readonly durableStore;
+    readonly isDraftId: (targetId: string) => boolean;
+    handlerId: string;
+    getDenormedRecord: (key: string) => Promise<DurableRecordRepresentation | undefined>;
+    constructor(getLuvio: () => Luvio, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, durableStore: DurableStore, isDraftId: (targetId: string) => boolean);
+    draftActionToDraftOperation(queueEntry: DraftAction<PerformUpdateRecordQuickActionResourceRequest, QuickActionExecutionRepresentation>): DraftRecordOperation[] | undefined;
+    handleActionEnqueued(action: PendingDraftAction<PerformUpdateRecordQuickActionResourceRequest>): Promise<void>;
+    canHandlePublish(_key: string): boolean;
+    canRepresentationContainDraftMetadata(_representationName: string): boolean;
+    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<RecordDraftMetadata | undefined>;
+    applyDraftsToIncomingData(key: string, data: unknown, _draftMetadata: {} | undefined, publishFn: (key: string, data: any) => void): void;
+    handleActionRemoved(action: DraftAction<ResourceRequest, QuickActionExecutionRepresentation>): Promise<void>;
+    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, QuickActionExecutionRepresentation>, _queueOperations: QueueOperation[], _allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
+    buildCacheKeysFromResponse(_response: QuickActionExecutionRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngest(response: QuickActionExecutionRepresentation): void;
+    mergeRequestBody<T>(): T;
+}
+export {};

package/dist/types/draftsAdapters/QuickActionExecutionRepresentation/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): DraftAwarePerformQuickActionAdapter;

package/dist/types/draftsAdapters/QuickActionExecutionRepresentation/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): DraftAwarePerformUpdateRecordQuickActionAdapter;

package/dist/types/draftsAdapters/RecordRepresentation/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/dist/types/draftsAdapters/RecordRepresentation/actionHandlers/RecordEffectingHandler.d.ts

@@ -0,0 +1,6 @@
+import type { DraftAction } from '@salesforce/lds-drafts';
+import type { DraftRecordOperation } from '../replayDraftsOnRecord';
+export interface RecordEffectingHandler {
+    draftActionToDraftOperation(queueEntry: DraftAction<unknown, unknown>): DraftRecordOperation[] | undefined;
+    handlerId: string;
+}

package/dist/types/draftsAdapters/RecordRepresentation/actionHandlers/UiApiRecordActionHandler.d.ts

@@ -0,0 +1,84 @@
+import type { Adapter, DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
+import type { GetRecordConfig, ObjectInfoRepresentation, RecordRepresentation, RecordRepresentationNormalized, RecordInputRepresentation } from '../../../adapters/main';
+import type { ActionHandler, CompletedDraftAction, DraftAction, DraftActionMetadata, DraftIdAndKeyMapping, DraftQueue, PendingDraftAction, QueueOperation } from '@salesforce/lds-drafts';
+import type { FieldRepresentation, ObjectInfoService } from '../../utils/types';
+import { AbstractResourceRequestActionHandler } from '@salesforce/lds-drafts';
+import type { DraftRecordOperation, RecordDraftMetadata } from '../replayDraftsOnRecord';
+import type { UiApiDraftRecordService, ReferenceIdFieldInfo } from '../../UiApiDraftRecordService';
+import type { RecordEffectingHandler } from './RecordEffectingHandler';
+import type { DurableStore } from '@luvio/environments';
+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, RecordDraftMetadata> implements RecordEffectingHandler {
+    protected readonly getLuvio: () => Luvio;
+    protected readonly networkAdapter: NetworkAdapter;
+    private readonly durableStore;
+    protected readonly draftQueue: DraftQueue;
+    private readonly getRecordAdapter;
+    private readonly objectInfoService;
+    readonly isDraftId: (targetId: string) => boolean;
+    private readonly recordService;
+    handlerId: string;
+    constructor(getLuvio: () => Luvio, networkAdapter: NetworkAdapter, durableStore: DurableStore, draftQueue: DraftQueue, getRecordAdapter: Adapter<GetRecordConfig, RecordRepresentation>, objectInfoService: ObjectInfoService, isDraftId: (targetId: string) => boolean, recordService: UiApiDraftRecordService);
+    buildPendingAction(request: RecordResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
+    getBackdatingFields(objectInfo: ObjectInfoRepresentation, requestMethod: string, pendingAction: PendingDraftAction<RecordResourceRequest>): {
+        [key: string]: string;
+    };
+    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, RecordRepresentation>): DraftIdAndKeyMapping[] | undefined;
+    handleActionCompleted(completedAction: CompletedDraftAction<ResourceRequest, RecordRepresentation>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
+    handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;
+    fetchReferenceRecord(referenceFields: ReferenceIdFieldInfo[]): Promise<void>;
+    /**
+     * 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
+     */
+    identifyApiName(id: string, fieldInfo: FieldRepresentation): Promise<string | undefined>;
+    canRepresentationContainDraftMetadata(representationName: string): boolean;
+    canHandlePublish(key: string): boolean;
+    buildTagForTargetId(id: string): string;
+    getIdFromRequest(request: RecordResourceRequest): Promise<string>;
+    getIdFromResponseBody(responseBody: RecordRepresentation): string;
+    draftActionToDraftOperation(action: DraftAction<RecordResourceRequest, RecordRepresentation>): DraftRecordOperation[];
+    getDraftMetadata(key: string): Promise<RecordDraftMetadata | undefined>;
+    isActionRecordAction(action: DraftAction<unknown, unknown>): action is DraftAction<RecordResourceRequest, RecordRepresentation>;
+    /**
+     * Gets the record associated with the passed in action
+     *
+     * @param action The draft action related to this record
+     * @param _queue The draft queue
+     * @returns The record with the updated draft queue applied. References are not included and must be applied at ingest.
+     *
+     * or
+     *
+     * undefined if the record no
+     * longer exists (i.e. the post action for a draft-created record was deleted)
+     *
+     * @throws if there are actions on an existing record but that record doesn't live in the durable store
+     */
+    getDataForAction(action: DraftAction<ResourceRequest, RecordRepresentation>): Promise<RecordRepresentation | undefined>;
+    applyDraftsToIncomingData(key: string, data: RecordRepresentationNormalized, draftMetadata: RecordDraftMetadata | undefined, publishData: (key: string, data: RecordRepresentationNormalized) => void): void;
+    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(response: RecordRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngest(response: RecordRepresentation): void;
+    mergeRequestBody<T>(targetBody: T, sourceBody: T): T;
+}
+export declare function isLDSDraftAction<Response>(action: DraftAction<unknown, unknown>): action is DraftAction<ResourceRequest, Response>;
+export {};

package/dist/types/draftsAdapters/RecordRepresentation/draftAwareAdapters/createRecord.d.ts

@@ -0,0 +1,9 @@
+import type { DraftAwareCreateRecordAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
+import type { DurableStore } from '@luvio/environments';
+/**
+ * @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;

package/dist/types/draftsAdapters/RecordRepresentation/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/dist/types/draftsAdapters/RecordRepresentation/draftAwareAdapters/updateRecord.d.ts

@@ -0,0 +1,9 @@
+import type { DraftAwareUpdateRecordAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { UiApiActionHandler } from '../actionHandlers/UiApiRecordActionHandler';
+import type { DurableStore } from '@luvio/environments';
+/**
+ * @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;

package/dist/types/draftsAdapters/RecordRepresentation/environment/getRecordDraftEnvironment.d.ts

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

package/dist/types/draftsAdapters/RecordRepresentation/environment/getRecordsDraftEnvironment.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio } from '@luvio/engine';
+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;

package/dist/types/draftsAdapters/RecordRepresentation/environment/makeEnvironmentUiApiRecordDraftAware.d.ts

@@ -0,0 +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';
+export interface DraftEnvironmentOptions {
+    store: InMemoryStore;
+    handler: UiApiActionHandler;
+    durableStore: DurableStore;
+    isDraftId: (id: string) => boolean;
+}
+export declare function makeEnvironmentUiApiRecordDraftAware(luvio: Luvio, options: DraftEnvironmentOptions, env: DraftAwareEnvironment): DraftAwareEnvironment;

package/dist/types/draftsAdapters/RecordRepresentation/records.d.ts

@@ -0,0 +1,30 @@
+import type { ResourceRequest, Luvio } from '@luvio/engine';
+import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+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/draftsAdapters/RecordRepresentation/replayDraftsOnRecord.d.ts

@@ -0,0 +1,40 @@
+import type { Luvio } from '@luvio/engine';
+import { type ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { FormatDisplayValue } from './actionHandlers/UiApiRecordActionHandler';
+import { type DraftRecordRepresentation } from './DraftRecordRepresentation';
+interface BaseDraftRecordOperation {
+    apiName: string;
+    id: string;
+    draftActionId: string;
+    timestamp: number;
+}
+export interface CreateDraftRecordOperation extends BaseDraftRecordOperation {
+    type: 'create';
+    fields: Record<string, any>;
+}
+export interface UpdateDraftRecordOperation extends BaseDraftRecordOperation {
+    type: 'update';
+    fields: Record<string, any>;
+}
+export interface DeleteDraftRecordOperation extends BaseDraftRecordOperation {
+    type: 'delete';
+}
+export type DraftRecordOperation = CreateDraftRecordOperation | UpdateDraftRecordOperation | DeleteDraftRecordOperation;
+export interface RecordDraftMetadata {
+    luvio: Luvio;
+    recordOperations: DraftRecordOperation[];
+    objectInfos: Map<string, ObjectInfoRepresentation>;
+    referencedRecords: Map<string, DraftRecordRepresentation>;
+    userId: string;
+    formatDisplayValue: FormatDisplayValue;
+}
+/**
+ * Replays an ordered draft list on top of a record. If undefined is passed in, the first draft must
+ * be a POST action
+ * @param record The base record to apply drafts to
+ * @param drafts The list of drafts to apply to the record
+ * @param userId The current user id, will be the last modified id
+ */
+export declare function replayDraftsOnRecord(record: DraftRecordRepresentation | undefined, draftMetadata: RecordDraftMetadata | undefined): DraftRecordRepresentation | undefined;
+export declare function applyReferenceLinksToDraft(record: DraftRecordRepresentation, draftMetadata: RecordDraftMetadata): DraftRecordRepresentation;
+export {};

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

@@ -0,0 +1,57 @@
+import type { Adapter, DurableStoreKeyMetadataMap, Luvio } from '@luvio/engine';
+import type { GetObjectInfoConfig, ObjectInfoRepresentation, RecordRepresentation } from '../adapters/main';
+import type { DraftAction, DraftQueue } from '@salesforce/lds-drafts';
+import type { FieldRepresentation } from './utils/types';
+import type { RecordEffectingHandler } from './RecordRepresentation/actionHandlers/RecordEffectingHandler';
+import type { DraftRecordRepresentation } from './RecordRepresentation/DraftRecordRepresentation';
+import type { RecordDraftMetadata } from './RecordRepresentation/replayDraftsOnRecord';
+import type { FormatDisplayValue } from './RecordRepresentation/actionHandlers/UiApiRecordActionHandler';
+import { type DurableStore } from '@luvio/environments';
+interface GetDraftMetadataStatusSuccess {
+    ok: true;
+    data: RecordDraftMetadata;
+    status: 'success';
+}
+interface GetDraftMetadataStatusReferenceRecordsMissing {
+    ok: true;
+    status: 'missing-referenced-records';
+    data: RecordDraftMetadata;
+    missingRecordReferences: ReferenceIdFieldInfo[];
+}
+interface GetDraftMetadataStatusObjectInfoMissing {
+    ok: false;
+    data: RecordDraftMetadata;
+    status: 'missing-object-info';
+}
+interface GetDraftMetadataStatusUnexpectedFields {
+    ok: false;
+    status: 'unexpected-fields';
+    data: RecordDraftMetadata;
+    fieldNames: string[];
+}
+type GetDraftMetadataStatus = GetDraftMetadataStatusSuccess | GetDraftMetadataStatusReferenceRecordsMissing | GetDraftMetadataStatusObjectInfoMissing | GetDraftMetadataStatusUnexpectedFields;
+export interface ReferenceIdFieldInfo {
+    id: string;
+    field: FieldRepresentation;
+}
+export declare class UiApiDraftRecordService {
+    private draftQueue;
+    private recordEffectingHandlers;
+    private getLuvio;
+    private durableStore;
+    private objectInfoAdapter;
+    private generateId;
+    private userId;
+    private formatDisplayValue;
+    constructor(draftQueue: DraftQueue, getLuvio: () => Luvio, durableStore: DurableStore, objectInfoAdapter: Adapter<GetObjectInfoConfig, ObjectInfoRepresentation>, generateId: (prefix: string) => string, userId: string, formatDisplayValue: FormatDisplayValue);
+    private queueToRecordOperations;
+    getRecordDraftMetadata(recordId: string, incomingAction: DraftAction<unknown, unknown> | undefined): Promise<GetDraftMetadataStatus | undefined>;
+    registerRecordHandler(recordHandler: RecordEffectingHandler): void;
+    synthesizeId(apiName: string): Promise<string>;
+    getKeyForId(id: string): string;
+    synthesizeDraftRecord(recordId: string): Promise<DraftRecordRepresentation | undefined>;
+    buildCacheKeysForRecordRepresentation(record: RecordRepresentation): DurableStoreKeyMetadataMap;
+    synchronousIngestRecord(record: RecordRepresentation): void;
+    getUserId(): string;
+}
+export {};

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

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

package/dist/types/draftsAdapters/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/dist/types/draftsAdapters/utils/clone.d.ts

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

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

@@ -0,0 +1,12 @@
+import { type DurableStore } from '@luvio/environments';
+import type { DurableRecordRepresentation, DurableRecordRepresentationField } from '@salesforce/lds-durable-records';
+/**
+ * Retrieves a denormalized record from the store
+ * NOTE: do no use this if you don't know what you're doing, this can still contain normalized record references
+ * @param recordKey record key
+ * @param durableStore the durable store
+ * @returns a DraftRecordRepresentation containing the requested fields
+ */
+export declare function getDenormalizedRecord(recordKey: string, durableStore: DurableStore): Promise<DurableRecordRepresentation | undefined>;
+export declare function isDraftFieldPending(field: DurableRecordRepresentationField): boolean;
+export declare function isDraftFieldMissing(field: DurableRecordRepresentationField): boolean;

package/dist/types/draftsAdapters/utils/error.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function takes an unknown error and normalizes it to an Error object
+ */
+export declare function normalizeError(error: unknown): Error;

package/dist/types/draftsAdapters/utils/language.d.ts

@@ -0,0 +1,40 @@
+declare const keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, values: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
+}, create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+}, freeze: {
+    <T extends Function>(f: T): T;
+    <T_1 extends {
+        [idx: string]: object | U | null | undefined;
+    }, U extends string | number | bigint | boolean | symbol>(o: T_1): Readonly<T_1>;
+    <T_2>(o: T_2): Readonly<T_2>;
+}, entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+declare const stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+}, parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+declare const shift: () => any;
+declare const isArray: (arg: any) => arg is any[], from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+    <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+};
+export { keys as ObjectKeys, values as ObjectValues, create as ObjectCreate, assign as ObjectAssign, freeze as ObjectFreeze, entries as ObjectEntries, stringify as JSONStringify, parse as JSONParse, shift as ArrayPrototypeShift, isArray as ArrayIsArray, from as ArrayFrom, };

package/dist/types/environment/enableLazyObjectInfoCaching.d.ts

@@ -1,5 +1,5 @@
 import type { Environment } from '@luvio/engine';
-import type { ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi-mobile';
+import type { ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
 export type EnsureCachedObjectInfoFunction = (apiName: string, objectInfo?: ObjectInfoRepresentation) => Promise<void>;
 /**
  * This environment observes incoming data for records and object info representations

package/dist/types/instrumentation/metrics.d.ts

@@ -8,8 +8,9 @@ export declare function reportGraphqlCreateSnapshotError(err: unknown): void;
 export declare function reportGraphQlEvalDbReadDuration(duration: number): void;
 export declare function reportGraphqlAdapterError(errorCode: string): void;
 export declare function reportGraphqlQueryInstrumentation(data: QueryInstrumentation): void;
-export declare function reportDraftActionEvent(state: 'added' | 'uploading' | 'completed' | 'deleted' | 'updated' | 'failed'): void;
-export declare function reportDraftQueueState(state: 'started' | 'error' | 'waiting' | 'stopped'): void;
+export declare function incrementGraphQLRefreshUndfined(): void;
+export declare function reportDraftActionEvent(state: 'added' | 'uploading' | 'completed' | 'deleted' | 'updated' | 'failed', draftCount: number, message?: string): void;
+export declare function reportDraftQueueState(state: 'started' | 'error' | 'waiting' | 'stopped', draftCount: number): void;
 export declare function reportDraftAwareContentDocumentVersionSynthesizeError(err: unknown): void;
 export declare function reportDraftAwareContentVersionSynthesizeCalls(mimeType: string): void;
 /** Priming */

package/dist/types/priming/LdsPrimingRecordRefresher.d.ts

@@ -1,5 +1,5 @@
 import type { Adapter } from '@luvio/engine';
-import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi-mobile';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
 import type { LdsRecordRefresher } from '@salesforce/lds-priming';
 export declare class LdsPrimingRecordRefresher implements LdsRecordRefresher {
     private getRecordsAdapter;

package/dist/types/priming/NimbusPrimingNetworkAdapter.d.ts

@@ -1,5 +1,5 @@
 import { type PrimingNetworkAdapter } from '@salesforce/lds-priming';
-import type { GraphQLRepresentation, GraphQLInputRepresentation, ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi-mobile';
+import type { GraphQLRepresentation, GraphQLInputRepresentation, ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
 import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
 export declare class NimbusPrimingNetworkAdapter implements PrimingNetworkAdapter {
     private sendRequestWithAbort;