@salesforce/lds-drafts 1.124.2 → 1.124.3

package/dist/{DraftQueue.d.ts → types/DraftQueue.d.ts}

@@ -1,233 +1,233 @@
-import type { FetchResponse } from '@luvio/engine';
-import type { ActionHandler } from './actionHandlers/ActionHandler';
-import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
-export declare enum DraftActionStatus {
-    Pending = "pending",
-    Uploading = "uploading",
-    Error = "error",
-    Completed = "completed"
-}
-export type DraftActionMetadata = {
-    [key: string]: string;
-};
-interface BaseDraftAction<Data> {
-    status: DraftActionStatus;
-    id: string;
-    /** Timestamp as unix epoch time */
-    timestamp: number;
-    metadata: DraftActionMetadata;
-    /** typically the cache key */
-    targetId: string;
-    /** typically the unique record ID  */
-    tag: string;
-    /** the handlerId */
-    handler: string;
-    /** the data being enqueued */
-    data: Data;
-    version: '242.0.0';
-}
-export interface CompletedDraftAction<Data, Response> extends BaseDraftAction<Data> {
-    status: DraftActionStatus.Completed;
-    response: FetchResponse<Response>;
-}
-export interface PendingDraftAction<Data> extends BaseDraftAction<Data> {
-    status: DraftActionStatus.Pending;
-}
-export interface ErrorDraftAction<Data> extends BaseDraftAction<Data> {
-    status: DraftActionStatus.Error;
-    error: any;
-}
-export interface UploadingDraftAction<Data> extends BaseDraftAction<Data> {
-    status: DraftActionStatus.Uploading;
-}
-export declare function isDraftCompleted<Data, Response>(draft: BaseDraftAction<Data>): draft is CompletedDraftAction<Data, Response>;
-export declare function isDraftError<Data>(draft: BaseDraftAction<Data>): draft is ErrorDraftAction<Data>;
-export declare function isDraftQueueStateChangeEvent(event: DraftQueueEvent): event is DraftQueueStateChangedEvent;
-export type DraftAction<Data, Response> = CompletedDraftAction<Data, Response> | PendingDraftAction<Data> | ErrorDraftAction<Data> | UploadingDraftAction<Data>;
-export type DraftQueueChangeListener = (event: DraftQueueEvent) => Promise<void>;
-export declare enum ProcessActionResult {
-    ACTION_ERRORED = "ERROR",
-    ACTION_SUCCEEDED = "SUCCESS",
-    NO_ACTION_TO_PROCESS = "NO_ACTION_TO_PROCESS",
-    ACTION_ALREADY_PROCESSING = "ACTION_ALREADY_PROCESSING",
-    NETWORK_ERROR = "NETWORK_ERROR",
-    BLOCKED_ON_ERROR = "BLOCKED_ON_ERROR",
-    CUSTOM_ACTION_WAITING = "CUSTOM_ACTION_WAITING"
-}
-export declare enum DraftQueueState {
-    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
-    Started = "started",
-    /**
-     * The queue is stopped and will not attempt to upload any drafts until startDraftQueue() is called.
-     * This is the initial state when the DraftQueue gets instantiated.
-     */
-    Stopped = "stopped",
-    /**
-     * The queue is stopped due to a blocking error from the last upload attempt.
-     * The queue will not run again until startDraftQueue() is called.
-     */
-    Error = "error",
-    /**
-     * There was a network error and the queue will attempt to upload again shortly.
-     * To attempt to force an upload now call startDraftQueue().
-     */
-    Waiting = "waiting"
-}
-export declare enum DraftQueueEventType {
-    /**
-     * Triggered after an action had been added to the queue
-     */
-    ActionAdded = "added",
-    /**
-     * Triggered once an action failed
-     */
-    ActionFailed = "failed",
-    /**
-     * Triggered after an action has been deleted from the queue
-     */
-    ActionDeleted = "deleted",
-    /**
-     * Triggered after an action has been completed and after it has been removed from the queue
-     */
-    ActionCompleted = "completed",
-    /**
-     * Triggered after an action has been updated by the updateAction API
-     */
-    ActionUpdated = "updated",
-    /**
-     * Triggered after the Draft Queue state changes
-     */
-    QueueStateChanged = "state"
-}
-export interface DraftQueueAddEvent {
-    type: DraftQueueEventType.ActionAdded;
-    action: PendingDraftAction<unknown>;
-}
-export interface DraftQueueDeleteEvent {
-    type: DraftQueueEventType.ActionDeleted;
-    action: DraftAction<unknown, unknown>;
-}
-export interface DraftQueueCompleteEvent {
-    type: DraftQueueEventType.ActionCompleted;
-    action: CompletedDraftAction<unknown, unknown>;
-}
-export interface DraftQueueActionFailedEvent {
-    type: DraftQueueEventType.ActionFailed;
-    action: ErrorDraftAction<unknown>;
-}
-export interface DraftQueueActionUpdatedEvent {
-    type: DraftQueueEventType.ActionUpdated;
-    action: DraftAction<unknown, unknown>;
-}
-export interface DraftQueueStateChangedEvent {
-    type: DraftQueueEventType.QueueStateChanged;
-    state: DraftQueueState;
-}
-export type DraftQueueItemEvent = DraftQueueAddEvent | DraftQueueCompleteEvent | DraftQueueDeleteEvent | DraftQueueActionFailedEvent | DraftQueueActionUpdatedEvent;
-export type DraftQueueEvent = DraftQueueStateChangedEvent | DraftQueueItemEvent;
-export declare enum QueueOperationType {
-    Add = "add",
-    Delete = "delete",
-    Update = "update"
-}
-export interface AddQueueOperation {
-    type: QueueOperationType.Add;
-    action: DraftAction<unknown, unknown>;
-}
-export interface DeleteQueueOperation {
-    type: QueueOperationType.Delete;
-    id: string;
-}
-export interface UpdateQueueOperation {
-    type: QueueOperationType.Update;
-    id: string;
-    action: DraftAction<unknown, unknown>;
-}
-export type QueueOperation = UpdateQueueOperation | AddQueueOperation | DeleteQueueOperation;
-export interface EnqueueResult<Data, Response> {
-    action: PendingDraftAction<Data>;
-    data: Response;
-}
-export interface DraftQueue {
-    /**
-     * Enqueues a draft action into the DraftQueue
-     * @param handlerId the id of the handler associated with the data
-     * @param data the data the handler will use to create the draft action with
-     * @returns A promise including the pending action created for the request and the data associated with the action
-     * @throws {Error} An error when a proper action handler is not found or conditions are not met to enqueue the action
-     */
-    enqueue<Data, Response>(handlerId: string, data: Data): Promise<EnqueueResult<Data, Response>>;
-    /**
-     * add a new handler to the draft queue to process the data in the actions
-     * @param id identifier to the handler
-     * @param handler ActionHandler to process action
-     */
-    addHandler<Data, Type>(handler: ActionHandler<Data, unknown, Type>): Promise<void>;
-    /**
-     * Creates a ActionHandler<CustomActionData> with a callback to let the DraftQueue know when it has been processed
-     * @param id identifier of the handler
-     * @param executor callback to inform DraftQueue it is complete
-     */
-    addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
-    /**
-     * Removes an added ActionHandler
-     * @param id identifier of the handler
-     */
-    removeHandler(id: string): Promise<void>;
-    /**
-     * Registers a listener to be notified when the Draft Queue changes
-     * @param listener Listener to notify when the draft queue changes, with an optional parameter
-     * for a completed DraftAction that triggered the change.
-     */
-    registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
-    /**
-     * Processes the next action in the draft queue
-     */
-    processNextAction(): Promise<ProcessActionResult>;
-    /**
-     * Get the current list of draft actions in queue
-     */
-    getQueueActions(): Promise<DraftAction<unknown, unknown>[]>;
-    /** The current state of the DraftQueue */
-    getQueueState(): DraftQueueState;
-    /**
-     * Removes the draft action identified by actionId from the draft queue.
-     *
-     * @param actionId The action identifier
-     */
-    removeDraftAction(actionId: string): Promise<void>;
-    /**
-     * Replaces the resource request of `withActionId` for the resource request
-     * of `actionId`. Action ids cannot be equal. Both actions must be acting
-     * on the same target object, and neither can currently be in progress.
-     *
-     * @param actionId The id of the draft action to replace
-     * @param withActionId The id of the draft action that will replace the other
-     */
-    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
-    /**
-     * Merges two actions into a single target action. The target action maintains
-     * its position in the queue, while the source action is removed from the queue.
-     * Action ids cannot be equal. Both actions must be acting on the same target
-     * object, and neither can currently be in progress.
-     *
-     * @param targetActionId The draft action id of the target action. This action
-     * will be replaced with the merged result.
-     * @param sourceActionId The draft action id to merge onto the target. This
-     * action will be removed after the merge.
-     */
-    mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
-    /** Set the draft queue state to Started and process the next item */
-    startQueue(): Promise<void>;
-    /** Set the draft queue state to Stopped and don't let another item begin */
-    stopQueue(): Promise<void>;
-    /**
-     * Sets the metadata object of the specified action to the
-     * provided metadata
-     *
-     * @param actionId The id of the draft action to set metadata on
-     * @param metadata The metadata to set on the specified action
-     */
-    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
-}
-export {};
+import type { FetchResponse } from '@luvio/engine';
+import type { ActionHandler } from './actionHandlers/ActionHandler';
+import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
+export declare enum DraftActionStatus {
+    Pending = "pending",
+    Uploading = "uploading",
+    Error = "error",
+    Completed = "completed"
+}
+export type DraftActionMetadata = {
+    [key: string]: string;
+};
+interface BaseDraftAction<Data> {
+    status: DraftActionStatus;
+    id: string;
+    /** Timestamp as unix epoch time */
+    timestamp: number;
+    metadata: DraftActionMetadata;
+    /** typically the cache key */
+    targetId: string;
+    /** typically the unique record ID  */
+    tag: string;
+    /** the handlerId */
+    handler: string;
+    /** the data being enqueued */
+    data: Data;
+    version: '242.0.0';
+}
+export interface CompletedDraftAction<Data, Response> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Completed;
+    response: FetchResponse<Response>;
+}
+export interface PendingDraftAction<Data> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Pending;
+}
+export interface ErrorDraftAction<Data> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Error;
+    error: any;
+}
+export interface UploadingDraftAction<Data> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Uploading;
+}
+export declare function isDraftCompleted<Data, Response>(draft: BaseDraftAction<Data>): draft is CompletedDraftAction<Data, Response>;
+export declare function isDraftError<Data>(draft: BaseDraftAction<Data>): draft is ErrorDraftAction<Data>;
+export declare function isDraftQueueStateChangeEvent(event: DraftQueueEvent): event is DraftQueueStateChangedEvent;
+export type DraftAction<Data, Response> = CompletedDraftAction<Data, Response> | PendingDraftAction<Data> | ErrorDraftAction<Data> | UploadingDraftAction<Data>;
+export type DraftQueueChangeListener = (event: DraftQueueEvent) => Promise<void>;
+export declare enum ProcessActionResult {
+    ACTION_ERRORED = "ERROR",
+    ACTION_SUCCEEDED = "SUCCESS",
+    NO_ACTION_TO_PROCESS = "NO_ACTION_TO_PROCESS",
+    ACTION_ALREADY_PROCESSING = "ACTION_ALREADY_PROCESSING",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    BLOCKED_ON_ERROR = "BLOCKED_ON_ERROR",
+    CUSTOM_ACTION_WAITING = "CUSTOM_ACTION_WAITING"
+}
+export declare enum DraftQueueState {
+    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
+    Started = "started",
+    /**
+     * The queue is stopped and will not attempt to upload any drafts until startDraftQueue() is called.
+     * This is the initial state when the DraftQueue gets instantiated.
+     */
+    Stopped = "stopped",
+    /**
+     * The queue is stopped due to a blocking error from the last upload attempt.
+     * The queue will not run again until startDraftQueue() is called.
+     */
+    Error = "error",
+    /**
+     * There was a network error and the queue will attempt to upload again shortly.
+     * To attempt to force an upload now call startDraftQueue().
+     */
+    Waiting = "waiting"
+}
+export declare enum DraftQueueEventType {
+    /**
+     * Triggered after an action had been added to the queue
+     */
+    ActionAdded = "added",
+    /**
+     * Triggered once an action failed
+     */
+    ActionFailed = "failed",
+    /**
+     * Triggered after an action has been deleted from the queue
+     */
+    ActionDeleted = "deleted",
+    /**
+     * Triggered after an action has been completed and after it has been removed from the queue
+     */
+    ActionCompleted = "completed",
+    /**
+     * Triggered after an action has been updated by the updateAction API
+     */
+    ActionUpdated = "updated",
+    /**
+     * Triggered after the Draft Queue state changes
+     */
+    QueueStateChanged = "state"
+}
+export interface DraftQueueAddEvent {
+    type: DraftQueueEventType.ActionAdded;
+    action: PendingDraftAction<unknown>;
+}
+export interface DraftQueueDeleteEvent {
+    type: DraftQueueEventType.ActionDeleted;
+    action: DraftAction<unknown, unknown>;
+}
+export interface DraftQueueCompleteEvent {
+    type: DraftQueueEventType.ActionCompleted;
+    action: CompletedDraftAction<unknown, unknown>;
+}
+export interface DraftQueueActionFailedEvent {
+    type: DraftQueueEventType.ActionFailed;
+    action: ErrorDraftAction<unknown>;
+}
+export interface DraftQueueActionUpdatedEvent {
+    type: DraftQueueEventType.ActionUpdated;
+    action: DraftAction<unknown, unknown>;
+}
+export interface DraftQueueStateChangedEvent {
+    type: DraftQueueEventType.QueueStateChanged;
+    state: DraftQueueState;
+}
+export type DraftQueueItemEvent = DraftQueueAddEvent | DraftQueueCompleteEvent | DraftQueueDeleteEvent | DraftQueueActionFailedEvent | DraftQueueActionUpdatedEvent;
+export type DraftQueueEvent = DraftQueueStateChangedEvent | DraftQueueItemEvent;
+export declare enum QueueOperationType {
+    Add = "add",
+    Delete = "delete",
+    Update = "update"
+}
+export interface AddQueueOperation {
+    type: QueueOperationType.Add;
+    action: DraftAction<unknown, unknown>;
+}
+export interface DeleteQueueOperation {
+    type: QueueOperationType.Delete;
+    id: string;
+}
+export interface UpdateQueueOperation {
+    type: QueueOperationType.Update;
+    id: string;
+    action: DraftAction<unknown, unknown>;
+}
+export type QueueOperation = UpdateQueueOperation | AddQueueOperation | DeleteQueueOperation;
+export interface EnqueueResult<Data, Response> {
+    action: PendingDraftAction<Data>;
+    data: Response;
+}
+export interface DraftQueue {
+    /**
+     * Enqueues a draft action into the DraftQueue
+     * @param handlerId the id of the handler associated with the data
+     * @param data the data the handler will use to create the draft action with
+     * @returns A promise including the pending action created for the request and the data associated with the action
+     * @throws {Error} An error when a proper action handler is not found or conditions are not met to enqueue the action
+     */
+    enqueue<Data, Response>(handlerId: string, data: Data): Promise<EnqueueResult<Data, Response>>;
+    /**
+     * add a new handler to the draft queue to process the data in the actions
+     * @param id identifier to the handler
+     * @param handler ActionHandler to process action
+     */
+    addHandler<Data, Type>(handler: ActionHandler<Data, unknown, Type>): Promise<void>;
+    /**
+     * Creates a ActionHandler<CustomActionData> with a callback to let the DraftQueue know when it has been processed
+     * @param id identifier of the handler
+     * @param executor callback to inform DraftQueue it is complete
+     */
+    addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
+    /**
+     * Removes an added ActionHandler
+     * @param id identifier of the handler
+     */
+    removeHandler(id: string): Promise<void>;
+    /**
+     * Registers a listener to be notified when the Draft Queue changes
+     * @param listener Listener to notify when the draft queue changes, with an optional parameter
+     * for a completed DraftAction that triggered the change.
+     */
+    registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
+    /**
+     * Processes the next action in the draft queue
+     */
+    processNextAction(): Promise<ProcessActionResult>;
+    /**
+     * Get the current list of draft actions in queue
+     */
+    getQueueActions(): Promise<DraftAction<unknown, unknown>[]>;
+    /** The current state of the DraftQueue */
+    getQueueState(): DraftQueueState;
+    /**
+     * Removes the draft action identified by actionId from the draft queue.
+     *
+     * @param actionId The action identifier
+     */
+    removeDraftAction(actionId: string): Promise<void>;
+    /**
+     * Replaces the resource request of `withActionId` for the resource request
+     * of `actionId`. Action ids cannot be equal. Both actions must be acting
+     * on the same target object, and neither can currently be in progress.
+     *
+     * @param actionId The id of the draft action to replace
+     * @param withActionId The id of the draft action that will replace the other
+     */
+    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
+    /**
+     * Merges two actions into a single target action. The target action maintains
+     * its position in the queue, while the source action is removed from the queue.
+     * Action ids cannot be equal. Both actions must be acting on the same target
+     * object, and neither can currently be in progress.
+     *
+     * @param targetActionId The draft action id of the target action. This action
+     * will be replaced with the merged result.
+     * @param sourceActionId The draft action id to merge onto the target. This
+     * action will be removed after the merge.
+     */
+    mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    /** Set the draft queue state to Started and process the next item */
+    startQueue(): Promise<void>;
+    /** Set the draft queue state to Stopped and don't let another item begin */
+    stopQueue(): Promise<void>;
+    /**
+     * Sets the metadata object of the specified action to the
+     * provided metadata
+     *
+     * @param actionId The id of the draft action to set metadata on
+     * @param metadata The metadata to set on the specified action
+     */
+    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
+}
+export {};

package/dist/{DraftStore.d.ts → types/DraftStore.d.ts}

@@ -1,12 +1,12 @@
-import type { DraftAction, QueueOperation } from './DraftQueue';
-import type { DraftKeyMapping } from './DraftIdMapping';
-/**
- * Defines the store where drafts are persisted
- */
-export interface DraftStore {
-    writeAction(action: DraftAction<unknown, unknown>): Promise<void>;
-    getAllDrafts(): Promise<DraftAction<unknown, unknown>[]>;
-    deleteDraft(actionId: string): Promise<void>;
-    deleteByTag(tag: string): Promise<void>;
-    completeAction(queueOperations: QueueOperation[], mappings: DraftKeyMapping[] | undefined): Promise<void>;
-}
+import type { DraftAction, QueueOperation } from './DraftQueue';
+import type { DraftKeyMapping } from './DraftIdMapping';
+/**
+ * Defines the store where drafts are persisted
+ */
+export interface DraftStore {
+    writeAction(action: DraftAction<unknown, unknown>): Promise<void>;
+    getAllDrafts(): Promise<DraftAction<unknown, unknown>[]>;
+    deleteDraft(actionId: string): Promise<void>;
+    deleteByTag(tag: string): Promise<void>;
+    completeAction(queueOperations: QueueOperation[], mappings: DraftKeyMapping[] | undefined): Promise<void>;
+}

package/dist/{DraftSynthesisError.d.ts → types/DraftSynthesisError.d.ts}

@@ -1,6 +1,6 @@
-export type DraftSynthesisErrorType = 'MISSING_ID' | 'OBJECT_INFO_MISSING' | 'REFERENCED_RECORDS_MISSING' | 'UNEXPECTED_FIELDS' | 'RECORD_NOT_CACHED' | 'UNKNOWN';
-export declare class DraftSynthesisError<T> extends Error {
-    errorType: T;
-    constructor(message: string, errorType: T);
-}
-export declare function isDraftSynthesisError<T>(error: Error): error is DraftSynthesisError<T>;
+export type DraftSynthesisErrorType = 'MISSING_ID' | 'OBJECT_INFO_MISSING' | 'REFERENCED_RECORDS_MISSING' | 'UNEXPECTED_FIELDS' | 'RECORD_NOT_CACHED' | 'UNKNOWN';
+export declare class DraftSynthesisError<T> extends Error {
+    errorType: T;
+    constructor(message: string, errorType: T);
+}
+export declare function isDraftSynthesisError<T>(error: Error): error is DraftSynthesisError<T>;

package/dist/{DurableDraftQueue.d.ts → types/DurableDraftQueue.d.ts}

@@ -1,52 +1,52 @@
-import type { DraftQueue, DraftAction, CompletedDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } from './DraftQueue';
-import { ProcessActionResult, DraftQueueState } from './DraftQueue';
-import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
-import type { ActionHandler } from './actionHandlers/ActionHandler';
-import type { DraftStore } from './DraftStore';
-export declare const DRAFT_SEGMENT = "DRAFT";
-export declare class DurableDraftQueue implements DraftQueue {
-    private retryIntervalMilliseconds;
-    private minimumRetryInterval;
-    private maximumRetryInterval;
-    private draftStore;
-    private draftQueueChangedListeners;
-    private state;
-    private userState;
-    private processingAction?;
-    private replacingAction?;
-    private uploadingActionId?;
-    private timeoutHandler;
-    private workerPool;
-    private handlers;
-    private getHandler;
-    constructor(draftStore: DraftStore);
-    addHandler<Data>(handler: ActionHandler<Data, unknown, unknown>): Promise<void>;
-    removeHandler(id: string): Promise<void>;
-    addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
-    getQueueState(): DraftQueueState;
-    startQueue(): Promise<void>;
-    stopQueue(): Promise<void>;
-    /**
-     * Used to stop the queue within DraftQueue without user interaction
-     */
-    private stopQueueManually;
-    getQueueActions<Data = unknown, Response = unknown>(): Promise<DraftAction<Data, Response>[]>;
-    enqueue<Data, Response>(handlerId: string, data: unknown): Promise<EnqueueResult<Data, Response>>;
-    registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
-    actionCompleted(action: CompletedDraftAction<unknown, unknown>): Promise<void>;
-    actionFailed(action: DraftAction<unknown, unknown>, retry: boolean): Promise<void>;
-    handle(action: DraftAction<unknown, unknown>): Promise<ProcessActionResult>;
-    processNextAction(): Promise<ProcessActionResult>;
-    private handleServerError;
-    private notifyChangedListeners;
-    /**
-     * only starts the queue if user state is "Started" and if queue not already
-     * started
-     */
-    private startQueueSafe;
-    removeDraftAction(actionId: string): Promise<void>;
-    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
-    mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
-    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
-    private scheduleRetry;
-}
+import type { DraftQueue, DraftAction, CompletedDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } from './DraftQueue';
+import { ProcessActionResult, DraftQueueState } from './DraftQueue';
+import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
+import type { ActionHandler } from './actionHandlers/ActionHandler';
+import type { DraftStore } from './DraftStore';
+export declare const DRAFT_SEGMENT = "DRAFT";
+export declare class DurableDraftQueue implements DraftQueue {
+    private retryIntervalMilliseconds;
+    private minimumRetryInterval;
+    private maximumRetryInterval;
+    private draftStore;
+    private draftQueueChangedListeners;
+    private state;
+    private userState;
+    private processingAction?;
+    private replacingAction?;
+    private uploadingActionId?;
+    private timeoutHandler;
+    private workerPool;
+    private handlers;
+    private getHandler;
+    constructor(draftStore: DraftStore);
+    addHandler<Data>(handler: ActionHandler<Data, unknown, unknown>): Promise<void>;
+    removeHandler(id: string): Promise<void>;
+    addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
+    getQueueState(): DraftQueueState;
+    startQueue(): Promise<void>;
+    stopQueue(): Promise<void>;
+    /**
+     * Used to stop the queue within DraftQueue without user interaction
+     */
+    private stopQueueManually;
+    getQueueActions<Data = unknown, Response = unknown>(): Promise<DraftAction<Data, Response>[]>;
+    enqueue<Data, Response>(handlerId: string, data: unknown): Promise<EnqueueResult<Data, Response>>;
+    registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
+    actionCompleted(action: CompletedDraftAction<unknown, unknown>): Promise<void>;
+    actionFailed(action: DraftAction<unknown, unknown>, retry: boolean): Promise<void>;
+    handle(action: DraftAction<unknown, unknown>): Promise<ProcessActionResult>;
+    processNextAction(): Promise<ProcessActionResult>;
+    private handleServerError;
+    private notifyChangedListeners;
+    /**
+     * only starts the queue if user state is "Started" and if queue not already
+     * started
+     */
+    private startQueueSafe;
+    removeDraftAction(actionId: string): Promise<void>;
+    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
+    mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
+    private scheduleRetry;
+}