@spiffcommerce/core 0.0.0-a2ce672c-2d8f-54fc-934a-a5036bd9742e

package/dist/index.d.ts

@@ -0,0 +1,3370 @@
+import * as _spiffcommerce_papyrus from '@spiffcommerce/papyrus';
+import { OptionResource, VariantResource, Step, AnyStepData, FrameOffsets, PatternImageData, Region, Workflow, ILayout, LayoutsState, LayoutData, Asset, MaterialResource, AssetType, StepType, AspectType, CommandState, CommandContext, GlobalPropertyConfigurationAspect, GlobalPropertyConfiguration, Theme, SilentStepData, Placeable, StepStorage, CanvasCommand, LayoutState, SerializableStep, FrameStepData, CreateElementCommand, FrameElement, ColorDefinition, IllustrationStepData, IllustrationElement, MaterialStepData, ModelStepData, TextStepData, TextboxElement, TextFillImage, FontData, GroupCommand, PictureStepData, QuestionStepData, ShapeStepData, ModuleStepData, DigitalContentStepData, FrameData as FrameData$1, InformationStepData } from '@spiffcommerce/papyrus';
+export { Animatable, AnyStepData, AspectType, Asset, AssetType, BringForwardCommand, BringToBackCommand, BringToFrontCommand, CanvasCommand, ColorDefinition, ColorProfileProps, CommandContext, CommandState, CreateElementCommand, CreateLayoutCommand, DeleteElementCommand, DigitalContentStepData, FontAlignmentCommand, FontColorCommand, FontSizeCommand, FontSourceCommand, FrameElement, FrameStepData, GroupCommand, ILayout, IllustrationElement, IllustrationStepData, ImageElement, InformationStepData, LayoutData, LayoutElement, LayoutElementFactory, LayoutElementType, LayoutsState, MaterialStepData, ModelStepData, ModuleStepData, MoveCommand, OptionResource, PictureStepData, Placeable, QuestionStepData, ResizeCommand, RotateCommand, SendBackwardsCommand, ShapeStepData, Step, StepAspect, StepAspectType, StepStorage, StepType, TextChangeCommand, TextStepData, TextboxElement, Theme, UnitOfMeasurement, UpdateImageSourceCommand, VariantResource, Workflow, WorkflowPanel, dataUrlFromExternalUrl, determineCorrectFontSizeAndLines, findElement, frameDataCache, generate, generateSVGWithUnknownColors, getAttributesFromArrayBuffer, getAxisAlignedBoundingBox, getFrameData, getSvgElement, loadFont, patternImageDataCache, registerFetchImplementation, registerWindowImplementation, rehydrateSerializedLayout, setCanvasModule } from '@spiffcommerce/papyrus';
+import { ApolloClient, MutationOptions, FetchResult } from '@apollo/client/core';
+import { RenderableContextService, RenderableContext, ThreeDPreviewService, ModelContainer } from '@spiffcommerce/preview';
+import * as lodash from 'lodash';
+
+declare class OptionService {
+    /**
+     * Allows for retrieving an option, returns the option from a cache if possible.
+     * @param id The option ID to be retrieved.
+     */
+    getOption(id: string): Promise<undefined | OptionResource>;
+    getAssetTileImageForVariant(variant: VariantResource): Promise<string>;
+    getDefaultVariant(option: OptionResource): VariantResource | undefined;
+    getDisplayImageSource: (variant?: VariantResource) => undefined | string;
+    /**
+     * Returns the first variant marked as selected. This is used by most steps.
+     */
+    getSelectedVariant: (option: OptionResource | undefined, selectedVariantIds: string[]) => VariantResource | undefined;
+}
+declare const optionService: OptionService;
+
+declare const setBearerAuthenticationToken: (token: string) => void;
+declare class GraphQlManager {
+    private shadowGraphqlClient;
+    constructor();
+    getShadowGraphqlClient(): ApolloClient<any>;
+    private constructShadowGraphqlClient;
+}
+declare const graphQlManager: GraphQlManager;
+
+/**
+ * A renderable scene is a scene that can be displayed to the user. This is based on the workflow state.
+ */
+interface RenderableScene {
+    /**
+     * The id of the scene.
+     */
+    id: string;
+    /**
+     * The title of the scene.
+     */
+    title: string;
+    /**
+     * The id of each step inside the scene that can be rendered. This is based on the workflow state.
+     */
+    renderableSteps: string[];
+    /**
+     * The WorkflowScene representation of this object. Provided for backwards compatibility.
+     * @deprecated
+     */
+    workflowScene: WorkflowScene;
+}
+/**
+ * Information parsed froma workflow structure that is relevant
+ * to a given scene.
+ */
+interface WorkflowScene {
+    /**
+     * A unique identifier for the scene.
+     */
+    name: string;
+    /**
+     * A human-readable title for the scene.
+     */
+    title: string;
+    /**
+     * Steps which can display to the user.
+     * But may be conditionally hidden based on workflow logic
+     */
+    renderableSteps: Step<AnyStepData>[];
+    /**
+     * Steps which don't display to the user.
+     * Their behavior is always silent & executed in the background.
+     * @deprecated Silent steps are no longer handled seperately from normal steps.
+     */
+    silentSteps: Step<AnyStepData>[];
+}
+
+/**
+ * A queue promise is a container for a promise that can be
+ * executed at a later time.
+ */
+declare abstract class QueueablePromise {
+    readonly timestamp: number;
+    abstract execute(): Promise<any>;
+}
+/**
+ * A promise queue contains any number of QueuePromise objects. These objects are stored within a PromiseQueue and executed
+ * as quickly as possible in order. This is ideal in situations where a specific operation should be
+ * applied in an ordered way while still making.
+ */
+declare class PromiseQueue<T extends QueueablePromise> {
+    private queue;
+    private activePromise?;
+    private queueMaxSize;
+    private isEnabled;
+    /**
+     * Constructs a new promise queue.
+     * @param queueMaxSize An optional maximum size, when the max size is hit.
+     *                     The older promises will be discarded.
+     * @param enabled When false, the queue will not process any jobs. Assign `enabled` to true to start processing.
+     */
+    constructor(queueMaxSize?: number, enabled?: boolean);
+    /**
+     * Enqueue a new promise.
+     * @param promise A new promise to add to the queue.
+     */
+    enqueue(promise: T): void;
+    get enabled(): boolean;
+    /**
+     * Enable or disable the queue. When disabled, the queue will not process any jobs.
+     * Disabling processing will not cancel any active promises.
+     */
+    set enabled(value: boolean);
+    /**
+     * @returns Returns true when work is being actively processed by this queue.
+     */
+    hasActivePromise(): boolean;
+    /**
+     * @returns The number of unexecuted jobs remaining in the queue. Not including the active job.
+     */
+    getRemainingQueueSize(): number;
+    /**
+     * Finalize the queue, any jobs that come in while this is in progress will result
+     * in the promise being extended.
+     */
+    finalize(): Promise<void>;
+    /**
+     * Once called will recursively resolve the jobs in the
+     * queue until no more are available.
+     */
+    private dequeue;
+}
+
+/**
+ * Bounds the offsets for an image to the box, preventing
+ * the user from moving the image in a way that wouldn't be intended.
+ * @param newOffsets The new intended offsets for the image.
+ * @param frameData The current frame information
+ * @param borderWidth The width of the border added by the cropper.
+ * @param mustCover When true the image sgould be bounded in such a way that it covers the entire frame at all times.
+ */
+declare function getBoundedOffsets(newOffsets: FrameOffsets, frameData: FrameData, imageData: PatternImageData, mustCover?: boolean): FrameOffsets;
+declare class FrameService {
+    private offsets;
+    private thresholdSettings;
+    private forceImageCover?;
+    private targetElements;
+    private imageData?;
+    private frameData?;
+    private readonly _debouncedUpdateFrameOffsets;
+    /**
+     * The calculated minimum zoom value, per frame.
+     */
+    minZoomScale: number[];
+    /**
+     * The calculated maximum zoom value. Note: This is calculated based on the first frame.
+     */
+    maxZoomScale: number[];
+    private onFrameDataChangeListeners;
+    private onZoomChangeListeners;
+    private workflowManager?;
+    private stepName?;
+    constructor(forceImageCover?: boolean);
+    /**
+     * When we want to connect a workflow manager to the state of the image cropper we
+     * can pass it to this function. Inside we'll attach any required event listeners.
+     * @param workflowManager The workflow manager to attach.
+     * @param stepName The specific step we want to attach to within the manager.
+     */
+    connectWorkflowManager(workflowManager: WorkflowManager, stepName?: string): void;
+    /**
+     * Sets the elements that should be update when changes are made to
+     * the cropper that owns this service.
+     * @param targetElements A list of element Ids to track
+     */
+    setTargetElements(targetElements: string[]): void;
+    /**
+     * Gets the current calculated frame data
+     * @returns A FrameData object or undefined if no frame has been set.
+     */
+    getFrameData(): FrameData[] | undefined;
+    /**
+     * Sets the current frame data. Note:
+     * @param paths The paths to lookup in our frame data cache.
+     */
+    setFrameData(paths: string[] | undefined): void;
+    /**
+     * Gets the currently set image of the frame..
+     * @returns A PatternImageData object, or undefined if no image is set.
+     */
+    getImageData(): PatternImageData | undefined;
+    /**
+     * Gets the current calculated offsets of the pattern within the frame.
+     * @returns A FrameOffsets object or undefined if no offsets are defined.
+     */
+    getOffsets(): FrameOffsets[] | undefined;
+    /**
+     * Updates the frame offsets explicitly.
+     */
+    setOffsets(offsets: FrameOffsets[]): void;
+    /**
+     * Sets the zoom of the cropper that owns this service.
+     * @param zoom The new zoom value, per frame.
+     * @param cX The center of zoom on x axis, per frame.
+     * @param cY The center of zoom on Y axis, per frame.
+     * @param onComplete A function to call when zoom changes have been completed
+     */
+    setZoom(zoom: number[], cX: number[], cY: number[], onComplete?: () => void): void;
+    /**
+     * Sets the image currently contained by this frame.
+     * @param value The new image as an ImageData property
+     * @param [recalculateOffsets=true] Optional: Enable/disable re-calculating of frame offsets. Default: `true`.
+     * Note: Will always calculate when offsets have not been calculated.
+     */
+    setPatternData(value: PatternImageData, recalculateOffsets?: boolean): void;
+    /**
+     * Modify the offsets of the frame.
+     * @param value The new FrameOffsets objects.
+     * @param onComplete A callback, called when the modification is complete
+     * @param forceUpdate When true the offsets will be updated even if they haven't changed.
+     */
+    updateOffsets(value: FrameOffsets[], onComplete?: () => void, forceUpdate?: boolean): void;
+    getThresholdSettings(): FrameThresholdSettings;
+    setThresholdSettings(settings: FrameThresholdSettings): void;
+    onFrameDataChanged(newListener: (frameData: FrameData[] | undefined) => void): void;
+    /**
+     * Append a new listener to zoom events on this frame.
+     * @param newListener
+     */
+    onZoom(newListener: (zoomValue: number[]) => void): void;
+    /**
+     * Updates the offsets of the frame
+     * @param newOffsets New offset object
+     * @param imageData The image data
+     * @param frameData The frame data
+     * @param targetElements A list of elements that need updating, by ID
+     * @param onComplete A callback when the operation is completed.
+     */
+    private updateFrameOffsets;
+    /**
+     * Determines limitations of zoom based on relative size of image and frame.
+     * @param imageData The image to include in calculations
+     * @param frameData The frame to include in calculations.
+     */
+    private recalculateZoomLimits;
+    private recalculateOffsets;
+}
+
+declare class Poller {
+    private pollingId;
+    private attempts;
+    private readonly interval;
+    private readonly maxAttempts;
+    private readonly predicate;
+    private readonly onSuccess;
+    private readonly onFailure;
+    private poll;
+    /**
+     * Constructs a new polling service.
+     * @param predicate An async function that returns true when polling has returned a successful result.
+     * @param onSuccess The callback to be called when polling has returned a successful result.
+     * @param onFailure The callback to be called when polling has returned a failed result.
+     * @param interval The number of milliseconds to wait between each poll.
+     * @param maxAttempts The maximum amount of times to check the condition.
+     */
+    constructor(predicate: () => Promise<boolean>, onSuccess: () => void, onFailure: () => void, interval?: number, maxAttempts?: number);
+}
+
+declare abstract class ModuleProduct {
+    /**
+     * Name used by class. Usually product or brand name.
+     */
+    abstract moduleName: string;
+    /**
+     * SVG with styled path positioned on a background image. To be displayed to user.
+     */
+    abstract svgPreview(text: string, region: Region): string;
+    /**
+     * SVG with styled path positioned on a background image. To be submitted for print.
+     */
+    abstract svgPrint(text: string, region: Region): string;
+}
+
+interface DesignInputStep {
+    data: DesignInputStepData;
+    name: string;
+}
+interface DesignInputStepData {
+}
+
+declare class LayoutPreviewService implements RenderableContextService {
+    private readonly layouts;
+    private handleCompleteRender;
+    constructor(layouts: ILayout[]);
+    setCompleteRenderCallback(handleCompleteRender: (layouts: LayoutPreviewBridge[]) => void): void;
+    onCompleteRender(): void;
+    getAll(): ReadonlyMap<string, LayoutPreviewBridge>;
+}
+/**
+ * The panel canvas class that stores both the main rendering canvas as well as rendering context
+ * for a rendering context
+ */
+declare class LayoutPreviewBridge implements RenderableContext {
+    hasSetStaticContext: boolean;
+    private readonly id;
+    private readonly name;
+    private readonly panelSize;
+    private service;
+    private interactiveDirty;
+    private textureCtx?;
+    private staticCtxDirty;
+    private lastRequestedRenderArguments;
+    private lastCompletedStaticRender;
+    private renderQueue;
+    constructor(id: string, name: string, service: LayoutPreviewService, panelSize: {
+        width: number;
+        height: number;
+    });
+    getID(): string;
+    getName(): string;
+    getPanelSize(): {
+        width: number;
+        height: number;
+    };
+    getStaticContext(): CanvasRenderingContext2D | undefined;
+    /**
+     * Register canvas to be rendered to.
+     */
+    setStaticContext(ctx: CanvasRenderingContext2D): void;
+    getStaticContextDirty(): boolean;
+    setStaticContextDirty(dirty: boolean): void;
+    getInteractiveCanvasDirty(): boolean;
+    setInteractiveCanvasDirty(dirty: boolean): void;
+    markLastCompletedStaticRender(): void;
+    /**
+     * Returns a timestamp for the last time that this canvas rendered to its dynamic texture in the
+     * form of Date.now(). If this panel has never rendered undefined will be returned.
+     */
+    getLastCompletedStaticRender(): number | undefined;
+    /**
+     * Actions to perform when a static render event is fired for this canvas.
+     */
+    render(layouts: LayoutData[]): Promise<void>;
+}
+interface StepAspectValue {
+    stepName: string;
+    stepAspectType: string;
+    value?: string;
+}
+declare const stepAspectValuesToDesignInputSteps: (stepAspectValues: StepAspectValue[], workflow: Workflow) => DesignInputStep[];
+declare const generateStateFromDesignInputSteps: (designInputSteps: DesignInputStep[], workflow: Workflow, layouts: ILayout[], productOverlayImageUrl?: string) => Promise<LayoutsState>;
+
+/**
+ * An asset manager provides a way to create and
+ * manage assets on the Spiff Commerce Platform.
+ */
+interface AssetManager {
+    /**
+     * Uploads a file to the Spiff Commerce Platform.
+     */
+    uploadFile: (file: File, onProgress: (val: number) => void) => Promise<Asset>;
+    /**
+     * From an existing asset, generates a new asset that has the background replaced with transparency.
+     * This process is idempotent, i.e. it will only run once for a given asset.
+     * @param asset The existing asset to remove the background from.
+     * @returns A promise that resolves with a new asset.
+     */
+    removeBackgroundFromAsset(asset: Asset): Promise<Asset>;
+}
+declare class AssetService implements AssetManager {
+    private cache;
+    /**
+     * Promise cache for BG removal processes. Values only present while process is active.
+     * Use BGRMStorage and the regular asset promise cache to cache the actual objects.
+     */
+    private bgrmProcessCache;
+    private materialCache;
+    /**
+     * Allows for retrieving an asset, returns the option from a cache if possible.
+     */
+    getLocalOrFromServer(assetKey: string): Promise<Asset>;
+    /**
+     * Retrieves the asset from the server, bypassing cache (but still writing the result to cache)
+     */
+    getFromServer(assetKey: string): Promise<Asset>;
+    keyFromURL(url: string): string | undefined;
+    /**
+     * Caches an asset if it doesn't already exist.
+     */
+    cacheAsset(asset: Asset): void;
+    /**
+     * Caches a material if it doesn't already exist.
+     */
+    cacheMaterial(material: MaterialResource): void;
+    /**
+     * Allows for retrieving a material, returns the option from a cache if possible.
+     * @param id The option ID to be retrieved.
+     */
+    getMaterialLocalOrFromServer(id: string): Promise<MaterialResource>;
+    /**
+     * Upload a user asset to the server. Using callbacks to notify important events.
+     * The asset will be stored via the persistence service for future access, if available.
+     */
+    uploadAssetWithProgress(file: FileInfo, assetType: AssetType, onProgress: (val: number) => void, anonymous?: boolean, temporary?: boolean): Promise<Asset>;
+    uploadAsset(file: FileInfo, assetType: AssetType, anonymous?: boolean, temporary?: boolean): Promise<Asset>;
+    uploadFile(file: File, onProgress: (val: number) => void): Promise<Asset>;
+    removeBackgroundFromAsset(asset: Asset): Promise<Asset>;
+    removePersistedAsset(assetKey: string): void;
+    getPersistedAssets(): PersistedAsset[];
+    registerPersistedAssetListener(callback: () => void): void;
+    unRegisterPersistedAssetListener(callback: () => void): void;
+    /**
+     * Convert a File object for an image into a FileInfo.
+     */
+    loadImageAsFileInfo: (file: File) => Promise<FileInfo>;
+    /**
+     * Handles mimeType resolution & asset creation request
+     * @param file A file info object containing data about the file and its name
+     * @param assetType The type of asset we're expecting to upload
+     */
+    private dispatchCreateAssetRequest;
+    private guessMIME;
+}
+interface PersistedAsset {
+    assetKey: string;
+    src: string;
+}
+declare const assetService: AssetService;
+
+/**
+ * A wrapping component that provides a simple interface for interacting with a variant.
+ */
+declare class Variant {
+    private readonly variantData;
+    constructor(variant: VariantResource);
+    getType(): AssetType | undefined;
+    /**
+     * @returns The unique identifier for the variant.
+     */
+    getId(): string;
+    /**
+     * @returns The configured name of the variant. Generally a human readable value.
+     */
+    getName(): string;
+    /**
+     * @returns The price modifier for this variant. This is the amount that will be added to the base price of the product.
+     */
+    getPriceFormatted(locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions | undefined): string;
+    /**
+     * @returns The price modifier for this variant. This is the amount that will be added to the base price of the product.
+     *          Presented in subunits of the currency of the option. For example, if the option is configured to use USD, the price modifier will be in cents.
+     */
+    getPrice(): number;
+    /**
+     * @returns The URL for the base asset resource configured on this variant
+     */
+    getAsset(): string | undefined;
+    /**
+     * @returns The URL for the base asset resource configured on this variant
+     */
+    getAssetResource(): Asset | undefined;
+    /**
+     * @returns The URL for a thumbnail resource configured on this variant.
+     */
+    getThumbnail(): string | undefined;
+    /**
+     * @returns The URL for the display image configured on this variant. Can be used for things like size charts.
+     * @deprecated To be removed in a future version, Please use getThumbnail() instead
+     */
+    getDisplayImage(): string | undefined;
+    /**
+     * @returns When this variant is configured to have a color, this will return the hex value for that color.
+     */
+    getColor(): string | undefined;
+    /**
+     * @returns True when the variant is the default for its containing option. False otherwise.
+     */
+    isDefault(): boolean;
+    /**
+     * @returns The underlying variant resource. Generally not needed but made available just incase.
+     */
+    getResource(): VariantResource;
+    /**
+     * @returns True when the variant is enabled. False otherwise.
+     */
+    isEnabled(): boolean;
+}
+
+/**
+ * A StepHandle allows for managing the state of a specific step in a workflow. This class
+ * abstracts away the complexities of dealing with a step directly and allows for using high level
+ * concepts instead of dealing with the underlying data structures.
+ */
+declare abstract class StepHandle<T extends AnyStepData> {
+    /**
+     * Stores whether or not the step is currently updating.
+     */
+    private static readonly updateState;
+    /**
+     * Access to the workflow manager this step is contained by.
+     */
+    protected readonly manager: WorkflowManager;
+    /**
+     * The step metadata, useful for determining logic based on configuration.
+     */
+    protected readonly step: Step<T>;
+    constructor(manager: WorkflowManager, step: Step<T>);
+    /**
+     * Set the current update state of this step. All step handles pointing to this step will
+     * see this value.
+     * @param value The new value
+     */
+    protected setUpdateState(value: boolean): void;
+    /**
+     * @returns Gets the current update state of this step. All step handles for this step will see this value.
+     */
+    protected getUpdateState(): boolean;
+    /**
+     * Gets the currently selected variant, or undefined if no variant is selected.
+     */
+    getCurrentVariant(): Variant | undefined;
+    /**
+     * @returns A list of valid variants for this step. Does not include disabled variants.
+     */
+    getAvailableVariants(): Variant[];
+    /**
+     * @returns A list of all variants for this step, including disabled ones.
+     */
+    getAllVariants(): Variant[];
+    /**
+     * Most step types have a base option type that variants can be selected for.
+     * Selects a specific variant for this step. This will execute all required changes to
+     * the design and update the metadata to include the new selection. Any conditions
+     * that would be triggered will also be executed.
+     */
+    abstract selectVariant(variant: Variant): Promise<void>;
+    /**
+     * @returns A unique identifier for this step within the workflow.
+     */
+    getId(): string;
+    /**
+     * @returns The name of the step
+     */
+    getName(): string;
+    /**
+     * @returns A message that can accompany the step name in UI components. Used to describe the purpose of the step in more detail.
+     */
+    getHelpText(): string | undefined;
+    /**
+     * @returns The type of the step handle.
+     */
+    getType(): StepType;
+    /**
+     * @returns The underlying data for this step. Favor using the step handle methods instead of this.
+     */
+    getRaw(): Step<T>;
+    getTags(): string[];
+    hasTag(tag: string): boolean;
+    /**
+     * @param type The AspectType to fetch the value for.
+     * @returns A boolean indicating whether this step should override Global Properties.
+     * Only relevant when the Workflow Experience is associated with a Bundle that is using Global Properties,
+     * and when this step is associated with one or more Global Property Aspects.
+     */
+    getOverrideGlobalPropertyConfiguration(type: AspectType): boolean;
+    /**
+     * Sets whether or not this step should override Global Properties.
+     * Only relevant when the Workflow Experience is associated with a Bundle that is using Global Properties,
+     * and when this step is associated with one or more Global Property Aspects.
+     * @param type The AspectType to override.
+     */
+    setOverrideGlobalPropertyConfiguration(type: AspectType, value: boolean): void;
+    /**
+     * Retrieves the identifiers of all of the configured aspects for the specified Global Property Configuration.
+     * @param configurationId The ID of the Global Property Configuration. You can usually find this with `bundle.getGlobalPropertyConfiguration()?.id`
+     * @returns An array of strings matching the keys of all the Global Property Aspects in the Configuration that this step is configured to use.
+     */
+    getGlobalPropertyAspects(configurationId: string): string[];
+    /**
+     * Fires any configured animations on the 3D preview for this step.
+     * This includes camera & model animations. If the preview is unavailable
+     * this function will do nothing.
+     */
+    executeAnimations(): void;
+}
+
+declare const createDesign: (workflowManager: WorkflowManager, workflow: Workflow, layouts: ILayout[], getReducerState: () => CommandState, product: Product, transaction: Transaction, workflowSelections: WorkflowSelections, designName: string, onProgressUpdate: DesignCreationProgressUpdate, createPreviewImage: (shouldRender3D?: boolean, transactionId?: string) => Promise<string | undefined>, workflowMetadata?: WorkflowMetadata) => Promise<DesignCreationMessage>;
+interface SavedDesign {
+    /**
+     * The user's name for this saved design.
+     */
+    title: string;
+    /**
+     * A URL pointing to an image of the design. Typically a data URL
+     */
+    thumbnail?: string;
+    /**
+     * The ID of the transaction relating to this design.
+     */
+    transactionId: string;
+    /**
+     * The product ID for this transaction.
+     */
+    productId: string;
+    /**
+     * The integration product ID related to this order.
+     */
+    integrationProductId: string;
+    /**
+     * The name of the workflow annotated at time of save (may be different from current workflow name).
+     */
+    workflowName: string;
+    /**
+     * The ID of the workflow annotated at time of save.
+     */
+    workflowId: string;
+    /**
+     * The last edit that occured on this saved design.
+     */
+    lastEdited: Date;
+}
+/**
+ * The design service exposes helper functionality wrapping important design management operations.
+ * NOTE: In the future this interface should allow for storing/pulling designs from the server.
+ */
+declare class DesignService {
+    readonly localPersistenceKey = "designTransactions";
+    private storageMethod;
+    private designSavedListeners;
+    /**
+     * @param func The function to call when a design is saved.
+     */
+    attachSaveListener(func: (design: SavedDesign) => void): void;
+    /**
+     * @param func The function to remove from the list of listeners.
+     */
+    detachSaveListener(func: (design: SavedDesign) => void): void;
+    /**
+     * Gets the currently persisted designs.
+     */
+    getSavedDesigns(): Promise<SavedDesign[]>;
+    /**
+     * Search for a transaction that has been saved.
+     * @param transactionId The id to search for.
+     * @returns The transaction for the given id provided it has been saved. undefined if it doesn't exist.
+     */
+    getSavedDesignByTransaction(transactionId: string): Promise<SavedDesign | undefined>;
+    /**
+     * Saves a design to storage.
+     * @param design The design to save.
+     */
+    addDesign(design: SavedDesign): Promise<void>;
+    /**
+     * Change the user's name of the given saved design.
+     */
+    renameDesign(transactionId: string, title: string): Promise<void>;
+    /**
+     * Removes a given design from storage.
+     * @param transactionId
+     */
+    removeDesign(transactionId: string): Promise<void>;
+    private setDesigns;
+}
+declare const designService: DesignService;
+
+/**
+ * A scene is a collection of steps that can be used to group steps together.
+ */
+interface Scene {
+    /**
+     * The unique identifier for the scene.
+     */
+    id?: string;
+    /**
+     * The name of the scene.
+     */
+    name: string;
+    /**
+     * The steps that are part of the scene. A list of ids. See getStepById.
+     */
+    stepIds: string[];
+}
+/**
+ * State related to a workflow experience.
+ */
+interface ExperienceOptions {
+    product: Product;
+    transaction: Transaction;
+    workflow?: Workflow;
+    /**
+     * @deprecated favor inject / eject functions.
+     */
+    previewService?: ThreeDPreviewService;
+    modelContainer?: ModelContainer;
+    renderableContextService?: LayoutPreviewService;
+    layouts: ILayout[];
+    reloadedState?: LayoutsState;
+    /**
+     * When true the experience is intended to be immutable.
+     */
+    readOnly?: boolean;
+    /**
+     * A function that communicates state changes to the server.
+     */
+    stateMutationFunc: StateMutationFunc;
+    /**
+     * Should be set to true when the experience is loaded from an existing transaction.
+     * FIXME: Wouldn't we know this from existance of reloadedState
+     */
+    isReloadedTransaction?: boolean;
+    /**
+     * When true the system will treat steps with
+     * a single variant as renderable. False
+     * by default.
+     */
+    singleVariantsRenderable?: boolean;
+    /**
+     * When true, will delay syncing the workflow state until manually enabled.
+     */
+    delayWorkflowStateSync?: boolean;
+}
+/**
+ * A Workflow experience encapsulates the workflow manager and command context. It
+ * provides a simplified interface for interacting with the workflow manager. You
+ * should get an instance of this class from a Client you have constructed previously.
+ */
+interface WorkflowExperience {
+    /**
+     * Get the bundle this experience is part of. May be undefined.
+     */
+    getBundle(): Bundle$1 | undefined;
+    /**
+     * Set the bundle this experience is part of. Can be cleared using undefined.
+     */
+    setBundle(bundle: Bundle$1 | undefined): any;
+    /**
+     * Returns the client that was responsible for spawning this experience.
+     */
+    getClient(): SpiffCommerceClient;
+    /**
+     * State related to the design of the user.
+     */
+    getCommandContext(): CommandContext;
+    /**
+     * Returns true when the user may only view the design.
+     */
+    getIsReadOnly(): boolean;
+    /**
+     * Get the low level workflow amanager instance for this experience. Don't touch this unless you're willing to break things.
+     */
+    getWorkflowManager(): WorkflowManager;
+    /**
+     * Returns the step matching a given name, undefined if not found.
+     * @param id The id the step must match.
+     */
+    getStepById(id: string): StepHandle<AnyStepData> | undefined;
+    /**
+     * Returns the step matching a given name, undefined if not found.
+     * @param name The name the step must match.
+     */
+    getStepByName(name: string): StepHandle<AnyStepData> | undefined;
+    /**
+     * Returns all steps matching a specific type in the workflow. These steps
+     * may be across multiple scenes and may or may not be active based on condition state.
+     */
+    getStepsByType(type: StepType): StepHandle<AnyStepData>[];
+    /**
+     * Returns all steps that are children of a given scene.
+     * @param scene The scene you want the steps for.
+     */
+    getStepsByScene(scene: Scene): StepHandle<AnyStepData>[];
+    /**
+     * Returns all steps in the workflow that are currently active. Ordered by scene and appearance within their respective scenes.
+     */
+    getSteps(): StepHandle<AnyStepData>[];
+    /**
+     * Returns a list of scenes that are configured in the workflow. Each scene
+     * contains a list of steps. See getStepsByScene to access these.
+     */
+    getScenes(): Scene[];
+    /**
+     * Returns the total cost in subunits for all selections made on the design.
+     * @param disablePriceBreaks Whether to exclude price breaks from the calculation.
+     */
+    getSelectionPriceSubunits(disablePriceBreaks?: boolean): number;
+    /**
+     * Returns the total cost in subunits for the base product.
+     * @param includeAdditionalProduct When true the additional product cost will be included in the total (if configured).
+     * @param disablePriceBreaks Whether to exclude price breaks from the calculation.
+     */
+    getBasePriceSubunits(includeAdditionalProduct?: boolean, disablePriceBreaks?: boolean): number;
+    /**
+     * If an additional product is configured, returns the base price of that product. Returns undefined otherwise.
+     * @param disablePriceBreaks Whether to exclude price breaks from the calculation.
+     */
+    getAdditionalProductPriceSubunits(disablePriceBreaks?: boolean): number | undefined;
+    /**
+     * A convenience function returning the sum of the selection and base price values.
+     * @param disablePriceBreaks Whether to exclude price breaks from the calculation.
+     */
+    getTotalPriceSubunits(disablePriceBreaks?: boolean): number;
+    /**
+     * The price break percentage that is expected to be applied in price calculations.
+     */
+    priceBreakToBeApplied(): number;
+    /**
+     * Calculates the price break and fires the "PriceBreakChanged" event if required.
+     * This function is primarily intended for internal use.
+     */
+    checkForPriceBreakChanges(): void;
+    /**
+     * Takes selections made by the user in another workflow and applies them to this workflow. For
+     * selections to be copied they must both have a matching global property configuration.
+     * @param experience The experience to take selections from.
+     * @param filter A list of steps to apply the selections to. If undefined all steps will be updated.
+     */
+    copySelectionsViaGlobalConfiguration(bundle: Bundle$1, experience: WorkflowExperience, filter?: StepHandle<AnyStepData>[]): Promise<void>;
+    /**
+     * Attach specific details about the customer to the experience. This is useful for things like retargeting. Currently only
+     * email is supported. From SpiffCommerce hosted experiences these details will be attached whenever the customer has provided & given permission.
+     * @param details The new customer details. Only email is supported.
+     * @deprecated Use assignCustomerDetails instead.
+     */
+    attachCustomerDetails(details: {
+        /**
+         * An email used for things like sending a design to the user.
+         */
+        email: string;
+    }): Promise<void>;
+    /**
+     * Attach specific details about the customer to the experience. This is useful for things like retargeting.
+     * From SpiffCommerce hosted experiences these details will be attached whenever the customer has provided & given permission.
+     * @param details The new customer details.
+     */
+    assignCustomerDetails(details: CustomerDetailsInput): Promise<void>;
+    /**
+     * Attaches a listener to the scenes on a workflow experience. The scenes returned are a subset of the scenes configured in the
+     * workflow and are based on the current state of the experience. This is useful for building a navigation menu.
+     * @param cb The callback to be called when the scenes change. The new scenes are passed as an argument.
+     */
+    attachRenderableSceneListener(cb: (scenes: RenderableScene[]) => void): void;
+    /**
+     * Detaches a listener from the scenes on a workflow experience.
+     */
+    detachRenderableSceneListener(cb: (scenes: RenderableScene[]) => void): void;
+    /**
+     * Saves this experience to storage. This may be local or remote depending
+     * on configuration.
+     * @param title The title for the saved design.
+     */
+    save(title: string): Promise<SavedDesign>;
+    /**
+     * Returns a copy of the currently loaded design as a new, seperated workflow experience with
+     * a fresh transaction.
+     */
+    copy(): Promise<WorkflowExperience>;
+    /**
+     * Creates a data URL preview for the current design.
+     */
+    createPreviewImage(isThreeD?: boolean, resolution?: number): Promise<string>;
+    /**
+     * To be called when the workflow experience is considered completed by the user.
+     * @param onProgressUpdate Progress callback for finalizing the design. Optional
+     * @param capturePreviewImage When true a preview image will be generated for the design. Defaults to true.
+     */
+    onDesignFinished(onProgressUpdate?: DesignCreationProgressUpdate, capturePreviewImage?: boolean): Promise<DesignCreationMessage>;
+    /**
+     * Returns the metadata associated with this workflow experience.
+     * This is a combination of the metadata from the workflow, and the selections made by the user.
+     */
+    getExportedData(): Map<string, {
+        [key: string]: string;
+    }>;
+    /**
+     * Get the quantity of this WorkflowExperience's Transaction.
+     * @returns The amount that was, or will be, ordered.
+     */
+    getQuantity(): number;
+    /**
+     * Sets the quantity of this WorkflowExperience's Transaction.
+     * @throws {Error} if the WorkflowExperience is read-only.
+     * @throws {RangeError} if the value is below 1.
+     * @param quantity The amount that was, or will be, ordered.
+     * @returns A promise that resolves when the Transaction has been updated on the server.
+     */
+    setQuantity(quantity: number): Promise<void>;
+    /**
+     * Registers a callback function to be called when the specified event is raised.
+     * @param type The type of event to listen for.
+     * @param callback The function to call when the event occurs.
+     */
+    addEventListener(type: WorkflowExperienceEventType, callback: (workflowExperience: WorkflowExperience) => void): void;
+    /**
+     * Removes a previously registered callback.
+     * @param type The type of event.
+     * @param callback The function to remove.
+     */
+    removeEventListener(type: WorkflowExperienceEventType, callback: (workflowExperience: WorkflowExperience) => void): void;
+}
+declare enum WorkflowExperienceEventType {
+    QuantityChanged = "QuantityChanged",
+    PriceBreakChanged = "PriceBreakChanged"
+}
+declare class WorkflowExperienceImpl implements WorkflowExperience {
+    readonly client: SpiffCommerceClient;
+    readonly commandContext: CommandContext;
+    readonly workflowManager: WorkflowManager;
+    readonly isReadOnly: boolean;
+    readonly cachedStepHandles: Map<string, StepHandle<any>>;
+    /**
+     * Bundle this experience has been added to.
+     */
+    private bundle?;
+    private currentPriceBreak;
+    private renderableScenes;
+    private renderableSceneCallbacks;
+    private eventCallbacks;
+    constructor(client: SpiffCommerceClient, experienceOptions: ExperienceOptions);
+    getBundle(): Bundle$1 | undefined;
+    setBundle(bundle: Bundle$1): void;
+    getClient(): SpiffCommerceClient;
+    getIsReadOnly(): boolean;
+    getCommandContext(): CommandContext;
+    getWorkflowManager(): WorkflowManager;
+    createPreviewImage(isThreeD?: boolean, resolution?: number): Promise<string>;
+    getStepById(id: string): StepHandle<any> | undefined;
+    getSteps(): StepHandle<AnyStepData>[];
+    getScenes(): Scene[];
+    getSelectionPriceSubunits(disablePriceBreaks?: boolean): number;
+    getBasePriceSubunits(includeAdditionalProduct?: boolean, disablePriceBreaks?: boolean): number;
+    getAdditionalProductPriceSubunits(disablePriceBreaks?: boolean): number | undefined;
+    getTotalPriceSubunits(disablePriceBreaks?: boolean): number;
+    private getPriceSubUnitsAfterPriceBreaks;
+    priceBreakToBeApplied(): number;
+    checkForPriceBreakChanges(): void;
+    private getMatchingExperiencesFromBundle;
+    private updatePriceBreak;
+    copySelectionsViaGlobalConfiguration(bundle: Bundle$1, experience: WorkflowExperience, filter?: StepHandle<AnyStepData>[]): Promise<void>;
+    getStepByName(name: string): TextStepHandle | FrameStepHandle | ShapeStepHandle | InformationStepHandle | IllustrationStepHandle | MaterialStepHandle | ModelStepHandle | PictureStepHandle | QuestionStepHandle | undefined;
+    getStepsByType(type: StepType): StepHandle<AnyStepData>[];
+    getStepsByScene(scene: Scene): StepHandle<AnyStepData>[];
+    attachCustomerDetails(details: {
+        email: string;
+    }): Promise<void>;
+    assignCustomerDetails(details: CustomerDetailsInput): Promise<void>;
+    attachRenderableSceneListener(cb: (scenes: RenderableScene[]) => void): void;
+    detachRenderableSceneListener(cb: (scenes: RenderableScene[]) => void): void;
+    debouncedSavedDesignUpdate: lodash.DebouncedFunc<() => Promise<void>>;
+    save(title?: string): Promise<SavedDesign>;
+    copy(): Promise<WorkflowExperience>;
+    onDesignFinished(onProgressUpdate?: DesignCreationProgressUpdate, capturePreviewImage?: boolean): Promise<DesignCreationMessage>;
+    /**
+     * @param step The step to test against.
+     * @returns Returns true when a valid handle is implemented for a given step type. Certain steps don't support handles, such as silent illustrations.
+     */
+    private stepHasHandle;
+    private getCanvasObjectURLAsync;
+    getExportedData(): Map<string, {
+        [key: string]: string;
+    }>;
+    getQuantity(): number;
+    setQuantity(quantity: number): Promise<void>;
+    addEventListener(type: WorkflowExperienceEventType, callback: (workflowExperience: WorkflowExperience) => void): void;
+    removeEventListener(type: WorkflowExperienceEventType, callback: (workflowExperience: WorkflowExperience) => void): void;
+    private callEvent;
+}
+
+/**
+ * A GlobalPropertyHandle acts as an interface to global properties on our platform. Currently
+ * bundles can return a handle for any global properties associated to the collection.
+ */
+declare abstract class GlobalPropertyHandle {
+    protected readonly bundle: Bundle$1;
+    protected readonly property: GlobalPropertyConfigurationAspect;
+    constructor(bundle: Bundle$1, property: GlobalPropertyConfigurationAspect);
+    /**
+     * @returns The name of the global property. This is the key used to store the property in the state.
+     */
+    getName(): string;
+    /**
+     * @returns A human friendly title.
+     */
+    getTitle(): string;
+    /**
+     * @returns A human friendly description.
+     */
+    getDescription(): string;
+    /**
+     * @returns The type of the global property. Use this to determine how to render the property.
+     */
+    getType(): AspectType;
+    /**
+     * @returns The underlying property data object.
+     */
+    getRawProperty(): GlobalPropertyConfigurationAspect;
+    /**
+     * Applies the global state to all shared steps, if the state is set.
+     * @param targetExperiences Optionally filter the workflow experiences it should be applied to.
+     */
+    abstract applyGlobalState(targetExperiences?: WorkflowExperience[]): Promise<void>;
+    /**
+     * Returns all steps that share this property.
+     * @param targetExperiences Optionally filter the steps to only those in the given experiences.
+     */
+    protected getSharedSteps(targetExperiences?: WorkflowExperience[]): StepHandle<_spiffcommerce_papyrus.AnyStepData>[];
+    protected getStateValue(): string | undefined;
+}
+/**
+ * A file upload global property allows for setting a frame image against all shared steps.
+ */
+declare class FileUploadGlobalPropertyHandle extends GlobalPropertyHandle {
+    constructor(bundle: Bundle$1, property: GlobalPropertyConfigurationAspect);
+    /**
+     * Select an image to be used for all shared steps.
+     * @param asset The asset to use.
+     * @returns A promise resolving when all affected steps have been updated.
+     */
+    selectImage(asset: Asset): Promise<void>;
+    canUseBackgroundRemover(): Promise<boolean>;
+    /**
+     * Removes the background from an image, stores it in the state, and returns the new asset.
+     * @param applyNewAsset Optionally applies the new asset to all shared steps. Default: `true`.
+     * @returns A promise that resolves with the newly generated Asset.
+     */
+    removeBackgroundFromImage(applyNewAsset?: boolean): Promise<Asset>;
+    /**
+     * Returns `true` if the state has an image assigned, otherwise `false`.
+     */
+    hasImage(): boolean;
+    /**
+     * Retrieves the current image selection, if one exists.
+     * @returns A promise that resolves with an `Asset` object if one is assigned to the state, otherwise `undefined`.
+     */
+    getImage(): Promise<Asset | undefined>;
+    /**
+     * Retrieves the original, unmodified image selection, if one exists.
+     * @returns A promise that resolves with an `Asset` object if one is assigned to the state, otherwise `undefined`.
+     */
+    getOriginalImage(): Promise<Asset | undefined>;
+    /**
+     * Retrieves the version of the image selection that has the background removed, if one exists.
+     * @returns A promise that resolves with an `Asset` object if one is assigned to the state, otherwise `undefined`.
+     */
+    getBackgroundRemovedImage(): Promise<Asset | undefined>;
+    getUseOriginalImage(): boolean;
+    setUseOriginalImage(value: boolean): Promise<void>;
+    applyGlobalState(targetExperiences?: WorkflowExperience[]): Promise<void>;
+    private applyImageSelection;
+    private updateSharedStepStorage;
+}
+declare class TextGlobalPropertyHandle extends GlobalPropertyHandle {
+    constructor(bundle: Bundle$1, property: GlobalPropertyConfigurationAspect);
+    /**
+     * Gets the current text
+     */
+    getText(): string;
+    /**
+     * Set the text.
+     */
+    setText(text: string): Promise<void>;
+    applyGlobalState(targetExperiences?: WorkflowExperience[]): Promise<void>;
+    private applyTextSelection;
+}
+/**
+ * An option property handle represents a property that can
+ * affect the option of steps across multiple transactions.
+ */
+declare class OptionGlobalPropertyHandle extends GlobalPropertyHandle {
+    protected optionResource?: OptionResource;
+    constructor(bundle: Bundle$1, property: GlobalPropertyConfigurationAspect, optionResource: OptionResource | undefined);
+    /**
+     * Gets the currently selected variant, or undefined if no variant is selected.
+     */
+    getCurrentVariant(): Variant | undefined;
+    /**
+     * @returns A list of valid variants for this step. Does not include disabled variants.
+     */
+    getAvailableVariants(): Variant[];
+    /**
+     * @returns A list of all variants for this step, including disabled ones.
+     */
+    getAllVariants(): Variant[];
+    /**
+     * Select a given variant on the option for all shared steps.
+     * @param variant The variant to select.
+     */
+    selectVariant(variant: Variant): Promise<void>;
+    applyGlobalState(targetExperiences?: WorkflowExperience[]): Promise<void>;
+    private applyVariantSelection;
+}
+/**
+ * A color option property handle represents a property that can
+ * affect the option of steps across multiple transactions. This class is a specialization of the OptionGlobalPropertyHandle which includes functionality for
+ * setting custom color values when a custom color variant is selected.
+ */
+declare class ColorOptionGlobalPropertyHandle extends OptionGlobalPropertyHandle {
+    constructor(bundle: Bundle$1, property: GlobalPropertyConfigurationAspect, optionResource: OptionResource | undefined);
+    /**
+     * Sets a custom color on the global state.
+     */
+    setCustomColor(color: string): void;
+    /**
+     * Gets the custom color used by the global state.
+     */
+    getCustomColor(): string;
+}
+
+interface GlobalPropertyStateManager {
+    getInitializationPromise(): Promise<void>;
+    getGlobalPropertyState(): GlobalPropertyState | undefined;
+    getAspect(name: string): string | undefined;
+    getAspectStorage(name: string): GlobalPropertyStateAspectStorage | undefined;
+    /**
+     * Updates the value of a named aspect in the state.
+     * @param name The name (key) of the aspect. This must match the key in the associated Global Property Config
+     * @param value The value, represented as a string.
+     * @param storage Optional: Additional data storage for the aspect. Not specifying this parameter, or providing `undefined`, will not update the
+     * storage (if it already exists). Providing `null` will clear the existing storage.
+     */
+    setAspect(name: string, value: string, storage?: GlobalPropertyStateAspectStorage | null): Promise<void>;
+    setAspectStorage(name: string, storage: GlobalPropertyStateAspectStorage | null): Promise<void>;
+    setBundleOptions(bundleOptions?: BundleOptions): void;
+}
+interface BundleOptions {
+    additionalHeaders?: {
+        [key: string]: string;
+    };
+}
+
+/**
+ * A collection of products that can be used to form a bundle.
+ */
+declare class ProductCollection {
+    private readonly collection;
+    constructor(collection: ProductCollectionResource);
+    /**
+     * The ID of the product collection.
+     */
+    getId(): string;
+    /**
+     * The name of the collection.
+     */
+    getName(): string;
+    /**
+     * A list of products in this collections with useful helpers for interacting with them.
+     */
+    getProducts(): CollectionProduct[];
+    /**
+     * A list of products in this collections with useful helpers for interacting with them.
+     */
+    fetchProducts(): Promise<CollectionProduct[]>;
+    getTransformCollection(): TransformCollection$1 | undefined;
+    /**
+     * The raw collection resource. This is generally not needed and should be avoided.
+     */
+    getResource(): ProductCollectionResource;
+}
+/**
+ * A collection product is a product within a ProductCollection. It provides a simple interface for interacting with the product.
+ */
+declare class CollectionProduct {
+    private readonly product;
+    private readonly productResource;
+    constructor(productCollectionProduct: ProductCollectionProductResource);
+    /**
+     * The ID of the product in SpiffCommerce.
+     * @returns
+     */
+    getId(): string;
+    /**
+     * The name of the product. Human readable.
+     */
+    getName(): string;
+    /**
+     * A helper function for getting integrations
+     * @param type The type of integration you want.
+     * @param externalId An external integration ID to further filter by. Otherwise we return the first encountered.
+     * @returns The integration if found. Throws an error if not found as this data is typically a neccesity.
+     */
+    getIntegrationByType(type: IntegrationType, externalId?: string): IntegrationProductResource;
+    getCurrentIntegration(): IntegrationProductResource;
+    /**
+     * A helper function for pulling the default workflow.
+     */
+    getDefaultWorkflow(): ProductWorkflow$1;
+    /**
+     * @returns All workflows associated with this Product.
+     */
+    getAllWorkflows(): ProductWorkflow$1[];
+    /**
+     * A list of all integrations this product is connected to.
+     */
+    getIntegrations(): IntegrationProductResource[];
+    /**
+     * The raw product resource. This is generally not needed and should be avoided.
+     */
+    getResource(): Product;
+    /**
+     * Gets the base price of the product. Optionally include additional product pricing.
+     * @param includeAdditionalProduct Optionally include additional product pricing. You must provide at least one of the fields on this object.
+     * @returns
+     */
+    getBasePrice(includeAdditionalProduct?: {
+        /**
+         * The integration type to locate the additional product on.
+         */
+        integrationType?: IntegrationType;
+        /**
+         * The external ID of the integration to locate the additional product on.
+         */
+        externalId?: string;
+        /**
+         * The internal Spiff integration ID to locate the additional product on.
+         */
+        integrationId?: string;
+    }): number;
+}
+/**
+ * Represents a the relationship between a workflow and a product.
+ */
+declare class ProductWorkflow$1 {
+    private readonly workflow;
+    constructor(workflow: ProductWorkflow);
+    /**
+     * @returns The ID of this workflow, to be used when starting an experience.
+     */
+    getId(): string;
+    /**
+     * @returns The name of the workflow.
+     */
+    getName(): string;
+    /**
+     * An image to be used to display this workflow in a UI to the customer.
+     * @returns A resource URL.
+     */
+    getThumbnail(): string;
+}
+/**
+ * Represents a collection of transforms that can be applied inside a product collection.
+ */
+declare class TransformCollection$1 {
+    private readonly collection;
+    constructor(collection: TransformCollection);
+    /**
+     * @returns The ID of the transform collection.
+     */
+    getId(): string;
+    /**
+     * @returns The name of the transform collection.
+     */
+    getName(): string;
+    /**
+     * @returns The transforms in this collection.
+     */
+    getTransforms(): Transform[];
+}
+/**
+ * Represents the translations, rotation & scale of a product in 3D space.
+ */
+declare class Transform {
+    private readonly transform;
+    constructor(position: TransformCollectionTransform);
+    /**
+     * @returns The ID of the transform.
+     */
+    getId(): string;
+    /**
+     * @returns The name of the transform.
+     */
+    getName(): string;
+    /**
+     * @returns The transformation to be used to place the object.
+     */
+    get(): BundleStateTransform;
+}
+
+/**
+ * A bundle serves as a container for a set of workflow experience.
+ */
+interface Bundle$1 {
+    /**
+     * @returns The client that this bundle is associated with.
+     */
+    getClient(): SpiffCommerceClient;
+    /**
+     * @returns The id of the bundle entity in the Spiff Commerce system.
+     */
+    getId(): string;
+    /**
+     * @returns The name of the bundle.
+     */
+    getName(): string;
+    /**
+     * Set the name of the bundle.
+     * @param name The new name for the bundle.
+     * @returns A promise that resolves when the name has been updated in the Spiff Commerce system.
+     */
+    setName(name: string): Promise<void>;
+    /**
+     * @returns Custom metadata associated with this bundle.
+     */
+    getMetadata(): Map<string, string>;
+    /**
+     * Set custom metadata associated with this bundle.
+     * @param metadata Updated map of metadata items.
+     * @returns A promise that resolves when the metadata has been updated in the Spiff Commerce system.
+     */
+    setMetadata(metadata: Map<string, string>): Promise<void>;
+    /**
+     * Set the name and metadata for this bundle.
+     * @param name The new name for the bundle.
+     * @param metadata Updated map of metadata items.
+     * @returns A promise that resolves when the name and metadata have been updated in the Spiff Commerce system.
+     */
+    setNameAndMetadata(name: string, metadata: Map<string, string>): Promise<void>;
+    /**
+     * Returns true if this bundle is associated with a Product Collection that is linked to a Global Property Configuration
+     */
+    hasGlobalProperties(): boolean;
+    /**
+     * Get a handle to the global properties available within this bundle. Setting values
+     * via this method will make selections on all bundles that share the property.
+     */
+    getGlobalProperties(): Promise<GlobalPropertyHandle[]>;
+    /**
+     * Get the low level state manager for this bundle. Don't use this unless you know what you're doing.
+     */
+    getGlobalPropertyStateManager(): GlobalPropertyStateManager;
+    /**
+     * Get the total in subunits for all global properties in this bundle.
+     */
+    getGlobalPropertyTotalSubunits(): Promise<number>;
+    /**
+     * Return the total in subunits for this bundle. This is the sum of the total for all individual transactions.
+     */
+    getTotalSubunits(): number;
+    /**
+     * Retrieves the product collection associated with this bundle.
+     * If the bundle is not associated with a product collection, this method will return undefined.
+     */
+    getProductCollection(): ProductCollection | undefined;
+    /**
+     * Add another workflow experience to this bundle.
+     * @param experience The workflow experience to add to this bundle.
+     */
+    addWorkflowExperience(experience: WorkflowExperience): Promise<void>;
+    /**
+     * Adds multiple workflow experiences to this bundle.
+     * @param experiences The workflow experiences to add to this bundle.
+     */
+    addWorkflowExperiences(experiences: WorkflowExperience[]): Promise<void>;
+    /**
+     * Remove a workflow experience from this bundle.
+     * @param experience The workflow experience to remove from this bundle.
+     */
+    removeWorkflowExperience(experience: WorkflowExperience): Promise<void>;
+    /**
+     * Removes multiple workflow experiences from this bundle.
+     * @param experiences The workflow experiences to remove from this bundle.
+     */
+    removeWorkflowExperiences(experiences: WorkflowExperience[]): Promise<void>;
+    /**
+     * Remove a workflow experience from this bundle by transaction.
+     * @param transaction The transaction to remove from this bundle.
+     */
+    removeWorkflowExperienceByTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Removes multiple workflow experiences from this bundle by their transactions.
+     * @param transactions The transactions to remove from this bundle.
+     */
+    removeWorkflowExperiencesByTransactions(transactions: Transaction[]): Promise<void>;
+    /**
+     * Inserts the given workflow experience into the bundle at the given index.
+     * NOTE: If you intend to insert a workflow experience at the end of the bundle, use `addWorkflowExperience` instead as it is more efficient.
+     * @param experience The workflow experience to insert.
+     * @param index The index to insert the workflow experience at.
+     */
+    insertWorkflowExperience(experience: WorkflowExperience, index: number): Promise<void>;
+    /**
+     * Replaces a workflow experience at the given index with the given workflow experience. This essentially removes the old one and inserts the new one.
+     * @param index The index to replace the workflow experience at.
+     * @param experience The workflow experience to replace the old one with.
+     */
+    replaceWorkflowExperience(index: number, experience: WorkflowExperience): Promise<void>;
+    /**
+     * Swaps the workflow experiences at the given indices.
+     */
+    swapWorkflowExperiences(a: number, b: number): Promise<void>;
+    /**
+     * Returns all workflow experiences currently added to this bundle.
+     */
+    getWorkflowExperiences(): WorkflowExperience[];
+    /**
+     * Sort the list of workflow experiences. The sorting is performed locally, and then the order is updated in the Spiff Commerce system.
+     * @returns A promise that resolves when the re-ordering of the workflow experiences has been updated in the Spiff Commerce system.
+     * The sorting will occur immediately, but the promise will not resolve until the Spiff Commerce system has been updated.
+     */
+    sortWorkflowExperiences(sortFunc: (expA: WorkflowExperience, expB: WorkflowExperience) => number): Promise<void>;
+    /**
+     * @returns The number of workflow experiences in this bundle.
+     */
+    getWorkflowExperienceCount(): number;
+    /**
+     * Add a stakeholder to this bundle. If the stakeholder already exists, it will be updated. Write access to the bundle is required.
+     * @param customerDetails The details of the customer to add. The emailAddress field is required.
+     * @param stakeholderType The type of stakeholder to add. Defaults to Owner.
+     */
+    addStakeholder(customerDetails: CustomerDetailsInput, stakeholderType?: StakeholderType): Promise<void>;
+    /**
+     * Removes a stakeholder from this bundle. Write access to the bundle is required.
+     * @param emailAddress The email address of the stakeholder to remove.
+     */
+    removeStakeholder(emailAddress: string): Promise<void>;
+    /**
+     * Updates all stakeholders associated with this bundle. Write access to the bundle is required.
+     * @param stakeholders An array of stakeholders to update. Unknown stakeholders will be added, and absent stakeholders will be removed.
+     */
+    updateStakeholders(stakeholders: BundleStakeholderInput[]): Promise<void>;
+    /**
+     * Retrieves all stakeholders associated with this bundle.
+     */
+    getAllStakeholders(): Promise<BundleStakeholder[]>;
+    /**
+     * Finalizes all experiences within the bundle. This will return a promise that resolves when all experiences have been finalized.
+     * The promise resolves with a list of messages that indicate the status of each experience including
+     * helpful details like what product to add to cart on supported e-commerce platforms.
+     * @param onProgressUpdate A callback that will be called when the progress of the finalization changes.
+     * @param createPreviewImage A callback that will be called when a preview image is required. This is used to generate a preview image for the design.
+     * If this callback is not provided, no preview image will be generated.
+     * @returns {BundleDesignCreationMessage} An object containing an array of design messages, along with the Bundle's Id and the event type.
+     */
+    finish(onProgressUpdate?: DesignCreationProgressUpdate, createPreviewImage?: (workflowExperience: WorkflowExperience) => Promise<string | undefined>): Promise<BundleDesignCreationMessage>;
+    /**
+     * Add an event listener to this bundle.
+     * @param event The event to listen for. Currently only "conditional-global-properties-changed" is supported.
+     * @param listener The listener to call when the event occurs.
+     */
+    addEventListener(event: BundleEventType, listener: (e: BundleEvent) => void): void;
+    /**
+     * Remove a previously added event listener from this bundle.
+     */
+    removeEventListener(event: BundleEventType, listener: (e: BundleEvent) => void): void;
+    /**
+     * Retrieves the current preview service for this bundle, if one exists.
+     * If a preview service was specified when calling client.getExistingBundle, this will return that service.
+     * Call `setPreviewService` to update the preview service for this bundle.
+     */
+    getPreviewService(): ThreeDPreviewService | undefined;
+    /**
+     * Set the preview service for this bundle. This will update the preview service for all workflow experiences in this bundle, and will
+     * also automatically inject the preview service into any new workflow experiences that are added to this bundle.
+     * If this method is called with no arguments or undefined, the preview service will be removed from this bundle.
+     * @param previewService The preview service to use for this bundle.
+     * @returns A promise that resolves when the preview service has been updated for all workflow experiences in this bundle.
+     */
+    setPreviewService(previewService?: ThreeDPreviewService): Promise<void>;
+    /**
+     * Returns a promise that resolves when the bundle has been initialized.
+     * This will resolve immediately if the bundle has no experiences, or if the bundle has already been initialized.
+     */
+    getInitializationPromise(): Promise<void>;
+    /**
+     * Sets the position, rotation, and scale of a named transform for a workflow experience within this bundle.
+     * @param workflowExperience The workflow experience to update.
+     * @param transformName The name of the transform.
+     * @param transform An object containing `position`, `rotation`, and `scale` properties. Each property is an object with `x`, `y`, and `z` properties.
+     */
+    updateWorkflowExperienceTransform(workflowExperience: WorkflowExperience, transformName: string, transform: BundleStateTransform): Promise<void>;
+    /**
+     * Sets a transform of a workflow experience within this bundle to be the active one.
+     * @param workflowExperience The workflow experience to update.
+     * @param transform The name of the transform to make the active transform.
+     */
+    activateWorkflowExperienceTransform(workflowExperience: WorkflowExperience, transformName: string): Promise<void>;
+    /**
+     * @returns The raw Global Property Configuration that is in use, otherwise `undefined`.
+     */
+    getGlobalPropertyConfiguration(): GlobalPropertyConfiguration | undefined;
+    setBundleOptions(bundleOptions?: BundleOptions): any;
+}
+type BundleEventType = "conditional-global-properties-changed" | "workflow-experience-hover-enter" | "workflow-experience-hover-exit";
+type BundleEventData = ConditionalGlobalPropertiesChangedEventData | WorkflowExperienceHoverEventData;
+type BundleEvent = {
+    bundle: Bundle$1;
+    data: BundleEventData;
+    event: BundleEventType;
+};
+interface ConditionalGlobalPropertiesChangedEventData {
+    globalProperties: GlobalPropertyHandle[];
+}
+interface WorkflowExperienceHoverEventData {
+    workflowExperience: WorkflowExperience;
+}
+
+/**
+ * A list of node types available in executions
+ */
+declare enum NodeType {
+    Split = "Split",
+    TextJoin = "TextJoin",
+    TextSlice = "TextSlice",
+    TextUpper = "TextUpper",
+    TextLower = "TextLower",
+    ParseJson = "ParseJson",
+    TextBuilder = "TextBuilder",
+    Design = "Design",
+    OverlayImage = "OverlayImage",
+    OverlayText = "OverlayText",
+    TableGenerator = "TableGenerator",
+    QR = "QR",
+    CSV = "CSV",
+    PDF = "PDF",
+    PNG = "PNG",
+    Email = "Email",
+    LocationDelivery = "LocationDelivery",
+    TemplateEmail = "TemplateEmail",
+    Map = "Map",
+    Sort = "Sort",
+    Group = "Group",
+    InnerJoin = "InnerJoin",
+    Contains = "Contains",
+    Flatten = "Flatten",
+    KeyValuePairs = "KeyValuePairs",
+    ListConcatenate = "ListConcatenate",
+    Repeat = "Repeat",
+    Size = "Size",
+    ListBuilder = "ListBuilder",
+    MapBuilder = "MapBuilder",
+    PairBuilder = "PairBuilder",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    Equals = "Equals",
+    Present = "Present",
+    ManualOperation = "ManualOperation",
+    Switch = "Switch",
+    AssetMetadata = "AssetMetadata",
+    DataSelect = "DataSelect",
+    LayoutSelect = "LayoutSelect",
+    TransactionMetadata = "TransactionMetadata",
+    VariantSelection = "VariantSelection",
+    StartTerminal = "StartTerminal",
+    EndTerminal = "EndTerminal",
+    MiscNote = "MiscNote",
+    Assign = "Assign",
+    CsvVlookup = "CsvVlookup",
+    ProcessFlow = "ProcessFlow",
+    TemporaryAssetUrl = "TemporaryAssetUrl",
+    WebRequest = "WebRequest"
+}
+interface ExecutionNodeResponse {
+    id: string;
+    type: NodeType;
+    artifacts: string;
+}
+interface ExecutionResponse {
+    id: string;
+    nodes: ExecutionNodeResponse[];
+    completedAt?: string;
+    failedAt?: string;
+}
+/**
+ * A service containing functionality for interacting with the Spiff Commerce API to execute and inspect the result of process flows.
+ */
+declare class FlowService {
+    /**
+     *
+     * @param id
+     * @param inputs
+     * @param options
+     * @returns
+     */
+    execute(id: string, inputs: FlowExecutionInput[], options?: {
+        sleepTime?: number;
+        repeats?: number;
+    }): Promise<FlowExecutionResult>;
+}
+/**
+ * Handles preparing a flow input for transmission to the server.
+ */
+declare class FlowExecutionResult {
+    protected readonly execution: ExecutionResponse;
+    constructor(execution: ExecutionResponse);
+    /**
+     * @returns The raw response from the server.
+     */
+    getRaw(): ExecutionResponse;
+    /**
+     * @returns The nodes contained within the execution.
+     */
+    getNodes(): FlowExecutionNodeResult[];
+    /**
+     * @param type The type of node to return.
+     * @returns A list of nodes matching the requested type.
+     */
+    getNodesByType(type: NodeType): FlowExecutionNodeResult[];
+    /**
+     * @returns A list of input nodes that exist in this execution.
+     */
+    getInputs(): FlowExecutionNodeResult[];
+    /**
+     * @returns A list of out put nodes that exist in this execution.
+     */
+    getOutputs(): FlowExecutionNodeResult[];
+    /**
+     * @returns A date object representing the point in time this execution completed.
+     */
+    getCompletedAt(): Date | undefined;
+    /**
+     * @returns A date object representing the point in time this execution failed.
+     */
+    getFailedAt(): Date | undefined;
+}
+/**
+ * Handles preparing a flow input for transmission to the server.
+ */
+declare class FlowExecutionNodeResult {
+    protected readonly node: ExecutionNodeResponse;
+    constructor(node: ExecutionNodeResponse);
+    getId(): string;
+    getType(): NodeType;
+    getArtifacts(): Map<string, any>;
+    getArtifactByName<T>(name: string): T;
+}
+/**
+ * Handles preparing a flow input for transmission to the server.
+ */
+declare abstract class FlowExecutionInput {
+    protected readonly value: string;
+    constructor(value: string);
+    getRaw(): string;
+    getValueForTransmission(): string;
+}
+/**
+ * Represents the type of object being referenced by the input.
+ */
+declare const enum ObjectInputType {
+    Transaction = "Transaction",
+    Bundle = "Bundle",
+    Product = "Product",
+    Variant = "Variant",
+    Option = "Option",
+    LineItem = "LineItem",
+    Asset = "Asset"
+}
+declare class TextInput extends FlowExecutionInput {
+    constructor(input: string);
+}
+/**
+ * Handles validation of spiffObject structure for transmission to the server.
+ */
+declare class ObjectInput extends FlowExecutionInput {
+    constructor(id: string, type: ObjectInputType);
+    static validUUID(uuid: string): RegExpMatchArray | null;
+}
+/**
+ * Handles validation of array input for transmission to the server.
+ */
+declare class ArrayInput extends FlowExecutionInput {
+    constructor(elements: FlowExecutionInput[]);
+}
+
+declare class IntegrationProduct {
+    private readonly integrationProduct;
+    constructor(product: IntegrationProductResource);
+    getId(): string;
+    getResource(): IntegrationProductResource;
+    getBasePrice(): number;
+    getDefaultWorkflow(): ProductWorkflow$1;
+    getAllWorkflows(): ProductWorkflow$1[];
+}
+
+declare const getWorkflows: (ids: string[], options?: GetWorkflowGraphqlOptions) => Promise<Workflow[]>;
+declare const getWorkflow: (id: string, options?: GetWorkflowGraphqlOptions) => Promise<Workflow>;
+/**
+ * Options that can be used during instantiation of the SpiffCommerce Javascript Client.
+ * Please refer to the documentation for more information.
+ */
+interface ClientOptions {
+    /**
+     * When provided, the client will use the provided application key to
+     * authenticate with the SpiffCommerce API.
+     */
+    applicationKey?: string;
+}
+interface GetBundleGraphqlAssetsOptions {
+    metadata?: boolean;
+}
+interface GetBundleGraphqlProductCollectionOptions {
+    eagerFetchProducts?: boolean;
+}
+interface GetBundleGraphqlOptions {
+    productCollection?: GetBundleGraphqlProductCollectionOptions;
+    assets?: GetBundleGraphqlAssetsOptions;
+    additionalHeaders?: {
+        [key: string]: string;
+    };
+}
+interface GetBundleOptions {
+    /**
+     * Configuration for the graphQL request made for bundles. Allows for retrieval
+     * of additional data.
+     */
+    graphql?: GetBundleGraphqlOptions;
+}
+interface GetWorkflowGraphqlAssetsOptions {
+    metadata?: boolean;
+}
+interface GetWorkflowGraphqlOptions {
+    assets?: GetWorkflowGraphqlAssetsOptions;
+}
+interface GetWorkflowOptionsBase {
+    /**
+     * An existing preview service to use, instead of creating a new one.
+     */
+    previewService?: ThreeDPreviewService;
+    /**
+     * Configuration related to the
+     * workflow and how the system interprets it.
+     */
+    workflowConfiguration?: {
+        /**
+         * False by default, when true the system will treat
+         * steps with a single variant
+         * as being renderable.
+         */
+        singleVariantsRenderable?: boolean;
+    };
+    /**
+     * Configuration for the graphQL request made for workflows. Allows for retrieval
+     * of additional data.
+     */
+    graphql?: GetWorkflowGraphqlOptions;
+}
+interface GetWorkflowFromTransactionOptions extends GetWorkflowOptionsBase {
+    /** The existing Transaction to use. */
+    transactionId: string;
+    /** If set to true, the workflow will display in a read-only mode. */
+    readOnly?: boolean;
+    /** An existing workflow state, if available. */
+    workflowState?: string;
+    type: "transaction";
+}
+interface GetNewWorkflowOptionsBase extends GetWorkflowOptionsBase {
+    /** A name for the new transaction. */
+    designName?: string;
+    /** The workflow to load. */
+    workflowId: string;
+    /** An existing workflow state, if available. */
+    workflowState?: string;
+}
+interface GetWorkflowFromIntegrationProductOptions extends GetNewWorkflowOptionsBase {
+    integrationProductId: string;
+    type: "integration";
+}
+interface GetWorkflowFromExternalProductOptions extends GetNewWorkflowOptionsBase {
+    /** The external ID associated with an integration. */
+    externalIntegrationId: string;
+    /** The ID of the product from the external system. */
+    externalProductId: string;
+    type: "external";
+}
+type GetNewWorkflowOptions = GetWorkflowFromIntegrationProductOptions | GetWorkflowFromExternalProductOptions;
+type GetWorkflowOptions = GetWorkflowFromTransactionOptions | GetNewWorkflowOptions;
+/**
+ * The Spiff Commerce Javascript Client. Required for
+ * creating workflow experiences.
+ */
+declare class SpiffCommerceClient {
+    private options;
+    private initialized;
+    private currencyCode?;
+    private customer?;
+    private activeIntegration?;
+    /**
+     * @deprecated This object is passed to the WorkflowExperience constructor and is no longer needed on this object.
+     * Any functionality referencing this object will be removed in a future release.
+     */
+    private experienceOptions?;
+    constructor(options: ClientOptions);
+    /**
+     * @returns The asset manager allows for common operations related to assets
+     * and the Spiff Commerce platform.
+     */
+    getAssetManager(): AssetManager;
+    getCurrencyCode(): string;
+    getFlowService(): FlowService;
+    getIntegration(): Promise<Integration>;
+    canUseAddon(addonHandle: AddonHandle): Promise<boolean>;
+    /**
+     * Attempts to load persisted authentication information from local storage, and authenticate with the Spiff Commerce API.
+     * @param bundleId The ID of the bundle you intend to load.
+     * @returns An object containing the success status of the authentication attempt, and the type of stakeholder when successful.
+     */
+    authenticateBundleFromLocalStorage(bundleId: string): Promise<{
+        stakeholderType?: StakeholderType;
+        success: boolean;
+    }>;
+    /**
+     * Attempts to load persisted authentication information from local storage, and authenticate with the Spiff Commerce API.
+     * @param transactionId The ID of the transaction that the user is attempting to load.
+     * @returns An object containing the following:
+     * - `customLogoLink`: A link to a custom logo to display in the header.
+     * - `transactionReadOnly`: Whether or not the transaction is read-only. Shadow will not accept any changes to the transaction if this is set to true.
+     * - `stakeholderType`: The type of stakeholder that the user is authenticated as.
+     * - `success`: Whether or not the authentication was successful.
+     * @throws An error if the transaction is not found.
+     */
+    authenticateTransactionFromLocalStorage(transactionId: string): Promise<{
+        customLogoLink?: string;
+        transactionReadOnly?: boolean;
+        stakeholderType?: StakeholderType;
+        success: boolean;
+        theme?: Theme;
+    }>;
+    clearCustomer(): void;
+    clearCustomerForTransaction(transactionId: string): void;
+    getStakeholderTypeForTransaction(transactionId: string): StakeholderType | undefined;
+    getOrCreateCustomer(emailAddress: string): Promise<{
+        customer: Customer;
+        isAuthenticated: boolean;
+    }>;
+    private authenticateCustomerId;
+    /**
+     * Generates a verification code for the given email address.
+     * @param emailAddress The email address to generate a verification code for. The user will be sent an email with the verification code.
+     */
+    generateVerificationCode(emailAddress: string): Promise<void>;
+    /**
+     * Verifies the given email address with the given verification code.
+     * @param emailAddress The email address to verify.
+     * @param verificationCode The verification code to verify the email address with.
+     * @returns True if the verification was successful, false otherwise.
+     */
+    verifyCode(emailAddress: string, verificationCode: string): Promise<boolean>;
+    /**
+     * @param collectionId Optional: The id of the product collection that the bundle can use.
+     * @returns A bundle to be used for grouping and operating on large amounts of workflow experiences.
+     */
+    getNewBundle(collectionId?: string, initialMetadata?: {
+        [key: string]: string;
+    }, options?: GetBundleOptions): Promise<Bundle$1>;
+    /**
+     * Retrieves an existing bundle from the API, by id.
+     * @param bundleId The id of the bundle to retrieve.
+     * @param previewService Optional: A reference to an existing preview service to use. This can be assigned manually later.
+     * @param graphqlOptions Optional: Options to configure loading the workflow.
+     * @returns A bundle to be used for grouping and operating on large amounts of workflow experiences.
+     */
+    getExistingBundle(bundleId: string, previewService?: ThreeDPreviewService, 
+    /**
+     * @deprecated use GetBundleOptions instead. This attribute will be removed in the future.
+     */
+    graphqlOptions?: GetBundleGraphqlOptions, options?: GetBundleOptions): Promise<Bundle$1>;
+    /**
+     * Retrieves all existing bundle stakeholders from the API, for the currently authenticated customer.
+     * @returns An array of bundle stakeholders.
+     */
+    getBundleStakeholders(): Promise<BundleStakeholder[]>;
+    /**
+     * Creates a new instance of WorkflowExperience. A high level wrapper for workflows.
+     * @param workflowId The id of the workflow to be run. Deprecated: Provide options instead.
+     * @param workflowState An existing workflow state if available. Deprecated: Provide options instead.
+     * @param previewServiceConstructor A function called during initialization. Takes a class implementing ThreeDPreviewService in return.
+     * @param options Options to configure loading the transaction and workflow.
+     * @returns A workflow experience configured as requested.
+     */
+    getWorkflowExperience(workflowId?: string, workflowState?: string, previewServiceConstructor?: (workflow: Workflow) => ThreeDPreviewService, options?: GetWorkflowOptions): Promise<WorkflowExperience>;
+    /**
+     * Gets multiple workflow experiences at once.
+     * @param optionsArray An array of options to configure loading the transactions and workflows.
+     * NOTE: The `previewService` field on the option is currently unsupported in this function, as loading multiple models at once will likely cause performance issues.
+     * @param graphqlOptions Options to configure loading the workflows.
+     * @returns An array of workflow experiences configured as requested.
+     */
+    getWorkflowExperiences(optionsArray: GetWorkflowOptions[], graphqlOptions?: GetWorkflowGraphqlOptions): Promise<WorkflowExperience[]>;
+    /**
+     * Initialize the client from an integration product.
+     * @param integrationProductId The integration product to use.
+     * @deprecated Use getWorkflowExperience to initialize the experience.
+     */
+    initFromIntegrationProduct(integrationProductId: string): Promise<void>;
+    /**
+     * Initialize the client from an existing transaction.
+     * @param transactionId The id of the transaction
+     * @returns A promise resolving at initialization completion.
+     * @deprecated Use getWorkflowExperience to initialize the experience.
+     */
+    initFromTransaction(transactionId: string, readOnly?: boolean): Promise<void>;
+    /**
+     * @deprecated Remove when the initFrom functions are removed.
+     */
+    private getWorkflowExperienceDeprecated;
+    /**
+     * @deprecated The value this returns will be changed whenever `getWorkflowExperience()` is called. Use `workflowExperience.getWorkflowManager().getPreviewService()` instead.
+     * @returns The preview service that was provided during construction.
+     */
+    getPreviewService(): ThreeDPreviewService | undefined;
+    /**
+     * @deprecated The value this returns will be changed whenever `getWorkflowExperience()` is called. Use `WorkflowManager.getProduct()` instead.
+     * @returns The product associated with this client.
+     */
+    getProduct(): Product;
+    /**
+     * @deprecated The value this returns will be changed whenever `getWorkflowExperience()` is called. Use `WorkflowManager.getTransaction()` instead.
+     * @returns The transaction associated with this client.
+     */
+    getTransaction(): Transaction;
+    configureUrls(hubUrl: string, serverUrl: string, servicesApiUrl: string): void;
+    /**
+     * A function used to synchronize transaction state with the server.
+     * @param options New state details. To be spread into the query.
+     * @returns
+     */
+    private updateTransactionState;
+    storeCustomer(customer: Customer): void;
+    getIntegrationProductById(integrationProductId: string): Promise<IntegrationProduct>;
+    getIntegrationProductFromExternalIds(externalIntegrationId: string, externalProductId: string): Promise<IntegrationProduct>;
+    getIntegrationProduct(options: Extendable<{
+        type: "integration";
+        integrationProductId: string;
+    }> | Extendable<{
+        type: "external";
+        externalIntegrationId: string;
+        externalProductId: string;
+    }>): Promise<IntegrationProduct>;
+    getShareActionsForTransaction(transactionId: string): Promise<TransactionShareAction[] | undefined>;
+}
+
+interface SilentIllustrationStepData extends SilentStepData, Placeable {
+}
+interface EditedSteps {
+    [stepName: string]: boolean;
+}
+interface MandatorySteps {
+    [stepName: string]: boolean;
+}
+type StepElements = {
+    [key: string]: RegionElement[];
+};
+type StepInitialised = {
+    [key: string]: boolean;
+};
+type StepMetadata = FrameMetadata | IllustrationMetadata | ModuleMetadata | TextMetadata;
+interface WorkflowStorage {
+    [stepName: string]: StepStorage;
+}
+interface WorkflowMetadata {
+    [stepName: string]: StepMetadata;
+}
+interface WorkflowSelections {
+    [stepName: string]: {
+        selections: VariantResource[];
+    };
+}
+interface InformationResult {
+    message: string;
+    messageType: InformationMessageType;
+    stepID: string;
+}
+declare enum InformationMessageType {
+    Error = "Error",
+    Warning = "Warning",
+    Info = "Info"
+}
+/**
+ * Services required for the operaiton of individual steps.
+ */
+interface StepSpecificServices {
+    frameService?: FrameService;
+    module?: ModuleProduct;
+}
+type DesignCreationProgressUpdate = (message: string) => void;
+type ConfirmCallback = (isConfirmed: boolean) => void;
+type EditedCallback = (editedSteps: EditedSteps) => void;
+type ElementsCallback = (elements: StepElements) => void;
+type InformationResultCallback = (messages: InformationResult[]) => void;
+type InitCallback = (stepInitialised: StepInitialised) => void;
+type MakingAdjustmentsCallback = (makingAdjustments: string) => void;
+type MandatoryCallback = (mandatorySteps: MandatorySteps) => void;
+type MetadataCallback = (metadata: WorkflowMetadata) => void;
+type SelectionCallback = (callbackOptions: {
+    selectionCost: number;
+    selections: StepSelections;
+    traversableScenes: WorkflowScene[];
+}) => void;
+type StepSpecificStorageCallback = (selections: StepStorage) => void;
+type StorageCallback = (storage: WorkflowStorage) => void;
+type StateMutationFunc = (options?: Omit<MutationOptions, "mutation">) => Promise<FetchResult<any, Record<string, any>, Record<string, any>>>;
+interface WorkflowManager {
+    addPoller: (poller: Poller) => void;
+    addConfirmCallback: (callback: ConfirmCallback) => void;
+    addEditedCallback: (callback: EditedCallback) => void;
+    addElementsCallback: (callback: ElementsCallback) => void;
+    addInformationResultCallback: (callback: InformationResultCallback) => void;
+    addInitCallback: (callback: InitCallback) => void;
+    addMakingAdjustmentsCallback: (callback: MakingAdjustmentsCallback) => void;
+    addMandatoryCallback: (callback: MandatoryCallback) => void;
+    addMetadataCallback: (callback: MetadataCallback) => void;
+    addSelectionCallback: (callback: SelectionCallback) => void;
+    addStepSpecificStorageCallback: (callback: StepSpecificStorageCallback, stepName: string) => void;
+    addStorageCallback: (callback: StorageCallback) => void;
+    getCommandDispatcher: () => (command: CanvasCommand) => void;
+    getCommandContext: () => CommandContext;
+    getLayouts: () => ILayout[];
+    getAllLayoutData: () => LayoutState[];
+    getLayoutPreviewService: () => LayoutPreviewService | undefined;
+    getPreviewService: () => ThreeDPreviewService | undefined;
+    getProfanities: () => string[];
+    getRegionElements: (stepName: string) => RegionElement[];
+    getSerializedStep: (stepName: string, serializedSteps: SerializableStep[]) => SerializableStep | undefined;
+    getStepSpecificServices: (stepName: string) => StepSpecificServices | undefined;
+    getStepStorage: (stepName: string) => StepStorage | undefined;
+    getMetadata: (stepName: string) => StepMetadata | undefined;
+    getWorkflowMetadata: () => WorkflowMetadata;
+    getInformationResults(): InformationResult[];
+    getTransaction: () => Transaction;
+    getTransactionCustomer: () => Customer | undefined;
+    setTransactionCustomer: (customer: Customer) => void;
+    /**
+     * @deprecated Use setTransactionCustomer instead.
+     */
+    setTransactionCustomerDetails: (details: {
+        email: string;
+    }) => void;
+    getWorkflow: () => Workflow;
+    getWorkflowSelections: () => WorkflowSelections;
+    getProduct: () => Product;
+    /**
+     * A promise resolving when the initial state of the workflow has completed loading.
+     */
+    getInitializationPromise: () => Promise<void>;
+    /**
+     * Returns true when the initial state of the workflow has been loaded and settled.
+     */
+    isInitialized(): boolean;
+    markStepsAsInitialised: (stepNames: string[]) => void;
+    getUpdatesPending: () => boolean;
+    markUpdateCompleted: (id: string) => void;
+    markUpdatePending: () => string;
+    outstandingRequestsPromise: () => Promise<void>;
+    reset: () => Promise<void>;
+    setCurrentAdjustingStepId: (stepId: string) => void;
+    setEditedStatus: (stepName: string, status: boolean) => void;
+    setInformationResults: (results: InformationResult[]) => void;
+    setMandatoryFulfilled: (stepName: string, status: boolean) => void;
+    setSelectionsAndElements: (stepName: string, variants: VariantResource[], elements: RegionElement[], callback?: () => Promise<void>) => Promise<void>;
+    toggleDesignConfirmed: () => void;
+    updateMetadata: (stepName: string, update: any) => void;
+    /**
+     * @deprecated State updates are being pulled internally. This function will be removed in the future.
+     */
+    updateStateWithServerImmediate: (getReducerState: () => CommandState) => Promise<void>;
+    updateStorage: (stepName: string, update: StepStorage) => void;
+    getModelContainer: () => ModelContainer | undefined;
+    setModelContainer: (container: ModelContainer) => void;
+    /**
+     * Injects the model of this product into the preview service.
+     * This also overwrites the internal preview service.
+     * @param previewService The preview service to inject into.
+     * @param refocusCamera Optional: Run camera focus Defaults to `true`.
+     */
+    injectIntoPreviewService(previewService: ThreeDPreviewService, refocusCamera?: boolean): Promise<void>;
+    /**
+     * Ejects the model of this product from the preview service. This also sets the internal preview service to undefined.
+     */
+    ejectFromPreviewService(): void;
+    /**
+     * Enables or disables uploading of workflow state to the server.
+     * @param enabled When true, workflow state will be uploaded to the server.
+     */
+    setWorkflowStateSyncEnabled: (enabled: boolean) => void;
+    /**
+     * Returns the client that was responsible for spawning this manager.
+     */
+    getClient(): SpiffCommerceClient;
+    /**
+     * Re-fetches the transactionShareActions for this WorkflowManager's Transaction object.
+     * The updated transactionShareActions overwrite the existing values on the Transaction object returned by `getTransaction()`.
+     */
+    updateTransactionShareActions(): Promise<void>;
+}
+
+interface StepService<T extends AnyStepData> {
+    /**
+     * Initialize the given step, or reload from serialized data if present.
+     */
+    init(stepData: Step<T>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<any>;
+}
+interface FileInfo {
+    /**
+     * The name of the file.
+     */
+    name: string;
+    /**
+     * A blob object representing the
+     * data of the file.
+     */
+    blob: Blob;
+}
+/**
+ * A command along with a function to run afterwards.
+ */
+interface CommandWithFollowup {
+    command?: CanvasCommand;
+    followup?: () => Promise<void>;
+}
+/**
+ * The variant selections of a completed step.
+ */
+interface SelectedVariants {
+    [stepName: string]: {
+        id: string;
+        name: string;
+        priceModifier: number;
+    }[];
+}
+interface ExportedData {
+    [name: string]: {
+        value: string;
+        priceModifier: number;
+    };
+}
+interface DesignCreationMessage {
+    additionalExternalProductId?: string;
+    additionalExternalVariantId?: string;
+    baseCost?: number;
+    designExternalVariants?: DesignExternalVariant[];
+    designProductId?: string;
+    designProductVariantId?: string;
+    event: string;
+    exportedData: ExportedData;
+    externalCartProductId?: string;
+    externalCartProductVariantId?: string;
+    lineItemImageUrl: string;
+    metadata?: {
+        [stepName: string]: string;
+    };
+    optionsCost: number;
+    processExecutionId?: string;
+    quantity?: number;
+    selectedVariants?: SelectedVariants;
+    sku?: string;
+    transactionId: string;
+    transactionOwnerId?: string;
+    weight?: number;
+    workflowViewerLink: string;
+    workflowViewerReadOnlyLink: string;
+}
+interface BundleDesignCreationMessage {
+    bundleId: string;
+    items: DesignCreationMessage[];
+}
+/**
+ * Represents a transaction.
+ */
+interface Transaction {
+    /**
+     * A unique identifier for this transaction. Useful for reloading and
+     * modifying state of the transaction.
+     */
+    id: string;
+    /**
+     * User-supplied name for the associated design.
+     */
+    designName?: string;
+    /**
+     * The workflow associated with this transaction.
+     */
+    workflowId?: string;
+    /**
+     * Temporary ID that grants write permission to the transaction.
+     */
+    transactionOwnerId?: string;
+    /**
+     * The current state of the design.
+     */
+    workflowState?: string;
+    /**
+     * URL to a partner-specific logo intended to display during the workflow experience.
+     */
+    customLogoLink?: string;
+    /**
+     * URL to a logo intended to display at the periphery of the workflow experience.
+     */
+    workflowFooterLogoLink?: string;
+    /**
+     * URL to the corresponding integration in the REST API.
+     */
+    restApiIntegrationLink?: string;
+    /**
+     * URL to redirect to when a workflow is finished.
+     */
+    callbackUrl?: string;
+    /**
+     * Product that this transaction belongs to.
+     */
+    product?: Product;
+    /**
+     * The integration product related to this lineitem.
+     */
+    integrationProduct?: IntegrationProductResource;
+    /**
+     * Whether this transaction has previously been ordered.
+     */
+    isOrdered?: boolean;
+    /**
+     * @deprecated use isOrdered to check whether transaction has been ordered instead.
+     */
+    lineItem?: LineItem;
+    /**
+     * The external product variant ID representing the design product related
+     * to this transaction, null unless the createDesignProduct flag was set
+     * and the design was finalized using createDesign operation.
+     */
+    /**@deprecated use externalCartProductVariantId or designExternalVariants[x].externalProductVariantId instead of this moving forward */
+    externalDesignProductVariantId?: string;
+    /**
+     * The external product id representing the design product related
+     * to this transaction, null unless the createDesignProduct flag was set
+     * and the design was finalized using createDesign operation.
+     */
+    /**@deprecated use externalCartProductId or designExternalVariants[x].externalProductId instead of this moving forward. */
+    externalDesignProductId?: string;
+    /**
+     * The external product id representing the product related to the transaction.
+     * This value can hold any type of transaction such as design and standard products.
+     */
+    externalCartProductId?: string;
+    /**
+     * The external product variant id representing the product related to the transaction.
+     * This value can hold any type of transaction such as design and standard products.
+     */
+    externalCartProductVariantId?: string;
+    priceModifierTotal?: number;
+    /**
+     * URL to open the transaction in the workflow viewer.
+     */
+    workflowViewerLink?: string;
+    workflowViewerReadOnlyLink?: string;
+    previewImageLink?: string;
+    lastSyncedAt?: string;
+    /**
+     * The users who have access to this transaction.
+     */
+    stakeholders?: Stakeholder[];
+    /**
+     * The amount of this transaction that was, or will be, ordered
+     */
+    quantity?: number;
+    printFileUrl1?: string;
+    printFileUrl2?: string;
+    printFileUrl3?: string;
+    printFileUrl4?: string;
+    printFileUrl5?: string;
+    printFileName1?: string;
+    printFileName2?: string;
+    printFileName3?: string;
+    printFileName4?: string;
+    printFileName5?: string;
+    /**
+     * An array of objects containing information on additional products to add to the cart.
+     * Typically only available when being passed to {@link DesignCreationMessage}
+     */
+    designExternalVariants?: DesignExternalVariant[];
+    transactionShareActions?: TransactionShareAction[];
+}
+interface TransactionShareAction {
+    id: string;
+    title?: string;
+    precedence?: number;
+    stakeholderType?: string;
+    url?: string;
+}
+/**
+ * An object containing ids for an external product/variant that should be added to the cart alongside the base product/variant.
+ */
+interface DesignExternalVariant {
+    id?: string;
+    externalProductId?: string;
+    externalProductVariantId?: string;
+    skuCode?: string;
+}
+/**
+ * An integration product represents the connection of a product in SpiffCommerce with
+ * a product on a third party platform.
+ */
+interface IntegrationProductResource {
+    /**
+     * The ID of the IntegrationProduct entity. Used internally by SpiffCommerce.
+     */
+    id: string;
+    /**
+     * The ID of the product on the third party platform. For example a Shopify product ID.
+     */
+    externalProductId?: string;
+    /**
+     * The integration that this product is associated with. For example a Shopify integration.
+     */
+    integration?: Integration;
+    /**
+     * The ID of an additional product (on the third party platform) that should be added to the cart.
+     */
+    additionalExternalProductId?: string;
+    /**
+     * A supplementary ID for the additional product. Shopify uses the variant ids to add products to the cart.
+     */
+    additionalExternalVariantId?: string;
+    /**
+     * When the additionalExternalProductId is set, this is the IntegrationProduct that is associated with it.
+     * If no Spiff product has been associated with the additionalExternalProductId, this will be null.
+     */
+    additionalIntegrationProduct?: IntegrationProductResource;
+    /**
+     * The product that this integration product is associated with.
+     */
+    product?: Product;
+}
+interface Integration {
+    id: string;
+    enabled: boolean;
+    externalIntegrationId?: string;
+    type?: IntegrationType;
+    isCurrent?: boolean;
+    theme: Theme;
+    logo: string;
+    partner: Partner;
+}
+declare enum IntegrationType {
+    Hub = "Hub",
+    Shopify = "Shopify"
+}
+/**
+ * Fields found in a variant within a line item resource.
+ */
+interface LineItemVariant {
+    currencyCode: string;
+    optionName: string;
+    priceModifier: number;
+    stepName: string;
+    variantName: string;
+}
+interface LineItem {
+    id: string;
+    transactionId?: string;
+    previewImageUrl?: string;
+    product: Product;
+    quantity: number;
+    metadata?: LineItemMetadata[];
+    variants: LineItemVariant[];
+}
+interface LineItemMetadata {
+    stepName: string;
+    metadata: string;
+}
+interface ProductWorkflow {
+    friendlyName: string;
+    id: string;
+    index?: number;
+    present?: boolean;
+    imageUrl: string;
+    workflowName: string;
+}
+interface Partner {
+    id?: string;
+    name?: string;
+    currencyCode?: string;
+    customerDetailsPromptMarkdown?: string;
+    activeAddons?: AddonHandle[];
+}
+declare enum AddonHandle {
+    BackgroundRemover = "BackgroundRemover",
+    ConversionAccelerator = "Conversion Accelerator",
+    ProcessBuilder = "ProcessBuilder"
+}
+interface Product {
+    /**
+     * ID of the partner owner.
+     */
+    partnerId?: string;
+    partner?: Partner;
+    /**
+     * Whether a line item for this product is delivered as soon as the order is received.
+     */
+    autoprint: boolean;
+    /**
+     * Whether this product can be quickprinted.
+     */
+    canQuickprint?: boolean;
+    /**
+     * The internal identifier for this product.
+     */
+    id: string;
+    /**
+     * The human friendly name of the product.
+     */
+    name: string;
+    /**
+     * A description of the Product, written in Markdown.
+     */
+    description: string;
+    /**
+     * A URL to the image asset associated with this product.
+     */
+    imageUrl?: string;
+    /**
+     * A resource url for a 3D model used to represent this product
+     * in the 3d editor. If not available we assume the product doesn't support 3D.
+     */
+    modelUrl?: string;
+    /**
+     * A URL for the image used as an overlay on any workflows
+     * that incorporate a product overlay step.
+     */
+    overlayImageUrl?: string;
+    /**
+     * Words which can't be used in a workflow for this product.
+     */
+    profanities?: {
+        id: string;
+        createdAt: string;
+        userId: string;
+        word: string;
+    }[];
+    /**
+     * The max characters that can be typed for quickprint.
+     */
+    quickprintMaxLength?: number;
+    /**
+     * The name of the module to use for quickprint.
+     */
+    quickprintModuleName?: string;
+    /**
+     * If true, the product should be displayed in the client as if it is available.
+     * Should be displayed as if it is unavailable otherwise.
+     */
+    enabled: boolean;
+    /**
+     * Workflows which have been assigned to this product.
+     */
+    workflows?: ProductWorkflow[];
+    /**
+     * The base price of this product in sub units. Essentially the cost of the
+     * product without any customisations applied.
+     */
+    basePrice?: number;
+    /**
+     * The weight of this product.
+     */
+    weight?: number;
+    /**
+     * When specified, represents a pre-rendered image of this product to be
+     * displayed to customers while the 3D preview is loading.
+     */
+    preloadImageUrl?: string;
+    /**
+     * When set the store owner has configured this product to prompt for
+     * customer details. In hosted experience, we'll offer to collect this information from the customer. In
+     * bespoke UIs created using the Core SDK you will need to check this flag and request the data accordingly.
+     * See attachCustomerDetails on the WorkflowExperience for how to supply us with the details you collect.
+     */
+    promptForCustomerDetails?: boolean;
+    /**
+     * Configuration for conversion. Optional.
+     */
+    conversionConfiguration?: ConversionConfiguration;
+    integrationProducts?: IntegrationProductResource[];
+    productTags?: ProductTag[];
+    productImages?: ProductImage[];
+    /**
+     * The SKU of the product in the merchant's store.
+     */
+    sku?: string;
+    /**
+     * The Spiff SKU code for the product.
+     */
+    skuCode?: string;
+    /**
+     * Price breaks for this product when dealing with quantity.
+     */
+    priceBreaks?: ProductPriceBreak[];
+}
+interface ProductImage {
+    id: string;
+    precedence?: number;
+    asset: Asset;
+}
+/**
+ * A price break represents a minimum quantity of a product and the price that will be charged for that quantity.
+ * This can be seen as an override for the base price of the product.
+ */
+interface ProductPriceBreak {
+    /**
+     * The id of this price break.
+     */
+    id: string;
+    /**
+     * The minimum quantity of this price break. A positive integer.
+     */
+    minQty: number;
+    /**
+     * A percentage to apply to the overall price. A value between 0-1 where 1 retains 100% of the original price and 0 completely discounts it to free.
+     */
+    percentage: number;
+}
+interface ProductTag {
+    id: string;
+    name: string;
+}
+interface ColorOption {
+    id?: string;
+    fill?: string;
+    stroke?: string;
+    variant?: VariantResource;
+    colorProfileAssetKey?: string;
+}
+interface RegionElement {
+    id: string;
+    region?: Region;
+}
+interface FrameMetadata {
+    image: string;
+}
+interface IllustrationMetadata {
+    colors: string[];
+}
+interface ModuleMetadata {
+    text: string;
+}
+interface TextMetadata {
+    color?: string;
+    text: string;
+    fillImage?: string;
+}
+interface SelectionStorage {
+    selectedVariants?: VariantResource[];
+}
+interface TextStepStorage extends SelectionStorage {
+    color?: string;
+    defaultCleared?: boolean;
+    inputText?: string;
+    text?: string;
+    customiseAllText?: boolean;
+}
+type StepSelections = {
+    [key: string]: SelectionStorage;
+};
+interface FrameData {
+    /**
+     * The path data for a frame SVG
+     */
+    path: string;
+    /**
+     *  The viewbox width
+     */
+    width: number;
+    /**
+     * The viewbox height.
+     */
+    height: number;
+}
+interface FrameThresholdSettings {
+    useThreshold: boolean;
+    invertThreshold: boolean;
+    threshold: number;
+    thresholdSaturation: number;
+}
+/**
+ * Defines the different behaviors supported by the camera system
+ * for control when viewing a product.
+ */
+declare enum ProductCameraRig {
+    Orbit = 0,
+    Pan = 1
+}
+/**
+ * Defines the locations at which a conversion attempt can take place.
+ */
+declare enum ConversionLocation {
+    /**
+     * The client should expose a flow for allowing the user to optionally input details at any point.
+     */
+    Manual = "Manual",
+    /**
+     *  The client should show the conversion flow at the beginning of a workflow.
+     */
+    OnStart = "OnStart",
+    /**
+     * The client should allow the user to input details just before quitting the experience.
+     */
+    OnQuit = "OnQuit",
+    /**
+     * The client should ask the user for details prior to adding to cart.
+     */
+    OnEnd = "OnEnd"
+}
+/**
+ * The data configured to be requested.
+ */
+declare enum ConversionDataType {
+    Email = "Email",
+    FirstName = "FirstName",
+    LastName = "LastName",
+    Phone = "Phone"
+}
+interface ConversionData {
+    type: ConversionDataType;
+    mandatory: boolean;
+}
+/**
+ * The configuration for conversion, exposed on products currently.
+ */
+interface ConversionConfiguration {
+    id: string;
+    name?: string;
+    locations: ConversionLocation[];
+    requestedData: ConversionDataType[];
+    requestedDataItems: ConversionData[];
+    mandatory?: boolean;
+}
+/**
+ * Someone who has used a workflow experience and entered their contact details.
+ */
+interface Customer {
+    id?: string;
+    emailAddress: string;
+    firstName?: string;
+    lastName?: string;
+    phoneNumber?: string;
+    loginToken?: string;
+    partner?: Partner;
+    stakeholders?: Stakeholder[];
+    bundleStakeholders?: BundleStakeholder[];
+}
+interface CustomerDetailsInput {
+    emailAddress: string;
+    firstName?: string;
+    lastName?: string;
+    phoneNumber?: string;
+}
+declare enum StakeholderType {
+    Owner = "Owner",
+    Approver = "Approver",
+    Editor = "Editor",
+    Viewer = "Viewer"
+}
+interface Stakeholder {
+    id: string;
+    type?: StakeholderType;
+    transaction?: Transaction;
+    customer?: Customer;
+}
+interface Bundle {
+    id?: string;
+    bundleOwnerId?: string;
+    bundleStakeholders?: BundleStakeholder[];
+    bundleStateData?: string;
+    metadata?: {
+        key: string;
+        value: string;
+    }[];
+    name?: string;
+    partner?: Partner;
+    productCollection?: ProductCollectionResource;
+    transactions?: Transaction[];
+}
+interface BundleStakeholder {
+    id: string;
+    bundle?: Bundle;
+    customer?: Customer;
+    type?: StakeholderType;
+}
+interface BundleStakeholderInput {
+    type: StakeholderType;
+    customerDetails: CustomerDetailsInput;
+}
+type ProductCollectionResource = {
+    id: string;
+    globalPropertyConfiguration?: GlobalPropertyConfiguration;
+    productCollectionProducts?: ProductCollectionProductResource[];
+    name: string;
+    transformCollection?: TransformCollection;
+};
+type ProductCollectionProductResource = {
+    id: string;
+    productCollection?: ProductCollectionResource;
+    productCollectionId?: string;
+    product: Product;
+    productId: string;
+    workflowId?: string;
+};
+type GlobalPropertyState = {
+    id: string;
+    aspects: GlobalPropertyStateAspect[];
+};
+type GlobalPropertyStateAspect = {
+    name: string;
+    value: string;
+    type?: AspectType;
+    storage?: GlobalPropertyStateAspectStorage;
+};
+type GlobalPropertyStateAspectStorage = GlobalPropertyStateFileUploadStorage;
+type GlobalPropertyStateFileUploadStorage = {
+    originalAssetKey?: string;
+    backgroundRemovedAssetKey?: string;
+    useOriginalAsset?: boolean;
+};
+interface BundleStateTransform {
+    position: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
+}
+interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface TransformCollection {
+    id: string;
+    name: string;
+    transforms: TransformCollectionTransform[];
+}
+interface TransformCollectionTransform {
+    id: string;
+    name: string;
+    position: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
+}
+type Extendable<T> = T & {
+    [key: string]: any;
+};
+
+interface StorageService {
+    /**
+     * Get a value.
+     * @param key The key to lookup the value with.
+     */
+    get(key: string): string | undefined;
+    /**
+     * Set a value.
+     * @param key The key to set.
+     * @param val The new value.
+     */
+    set(key: string, val: string): void;
+    /**
+     * Remove a value.
+     * @param key The key to remove, does nothing if the key doesn't exist.
+     */
+    remove(key: string): void;
+    /**
+     * Get a map from persistence.
+     * @param key The key to search by.
+     */
+    getMap<K = any, V = any>(key: string): Map<K, V> | undefined;
+    /**
+     * St a map into persistence.
+     * @param key The key to set the map at.
+     * @param val The map to set.
+     */
+    setMap<K = any, V = any>(key: string, val: Map<K, V>): void;
+}
+declare const persistenceService: StorageService;
+
+declare class Configuration {
+    private readonly defaultServerUrl;
+    private readonly defaultServicesApiUrl;
+    private readonly defaultHubUrl;
+    private serverUrl;
+    private servicesApiUrl;
+    private hubUrl;
+    private serverUrlCallbacks;
+    constructor();
+    getServerUrl(): string;
+    getServicesApiUrl(): string;
+    getHubUrl(): string;
+    setServerUrl(serverUrl: string): void;
+    setServicesApiUrl(servicesApiUrl: string): void;
+    setHubUrl(hubUrl: string): void;
+    addServerUrlCallback(callback: () => void): void;
+}
+declare const spiffCoreConfiguration: Configuration;
+
+type ToastCallback = (callbackOptions: {
+    toastMessage: null | string;
+    toastType: InformationMessageType | null;
+}) => void;
+declare class Toast {
+    private latestToast;
+    private toastType;
+    private toastCallbacks;
+    constructor();
+    addToastCallback(callback: ToastCallback): void;
+    removeToastCallback(callback: ToastCallback): void;
+    setLatestToast(errorMessage: null | string, errorType: InformationMessageType | null): void;
+    private onToastChange;
+}
+declare const toast: Toast;
+
+interface FrameCreateOpts {
+    stepName?: string;
+    frameData: FrameData;
+    disablePlaceholder?: boolean;
+    focalBlur?: boolean;
+    focalBlurStrength?: number;
+    focalBlurRadius?: number;
+    pattern?: any;
+}
+declare class FrameStepService implements StepService<FrameStepData> {
+    init(stepData: Step<FrameStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    selectImage(stepData: Step<FrameStepData>, asset: Asset, workflowManager: WorkflowManager, recalculateOffsets?: boolean): Promise<void>;
+    selectVariant(stepData: Step<FrameStepData>, variant: VariantResource | undefined, elements: RegionElement[], workflowManager: WorkflowManager, setFrameIsUpdating?: (status: boolean) => void): Promise<void>;
+    getCreateElementCommand(id: string, region: Region, layout: ILayout, options: FrameCreateOpts): CreateElementCommand<FrameElement>;
+    loadPatternFromString(src: string, frameService: FrameService, recalculateOffsets?: boolean, colors?: {
+        [key: string]: ColorDefinition;
+    } | undefined): Promise<void>;
+    getPatternColors(stepData: Step<FrameStepData>, workflowManager: WorkflowManager): Promise<{
+        [key: string]: ColorDefinition;
+    }>;
+    changeColors(stepData: Step<FrameStepData>, workflowManager: WorkflowManager, newFills: Map<string, string>): Promise<void>;
+    private selectVariantCommand;
+    private frameSourceSvg;
+    /**
+     * Grab the source to be used for a frame from the variant or throw otherwise.
+     */
+    private patternSource;
+    private loadPatternFromAsset;
+}
+declare const frameStepService: FrameStepService;
+
+interface SVGCreateOpts {
+    stepName?: string;
+    src: string;
+    objectURL: string;
+    svg: {
+        svg: string;
+        colors: {
+            [key: string]: ColorDefinition;
+        };
+    };
+}
+declare class IllustrationStepService implements StepService<IllustrationStepData> {
+    getIllustrationBody(src: string): Promise<string>;
+    getCreateElementCommand(id: string, region: Region, layout: ILayout, options: SVGCreateOpts): CreateElementCommand<IllustrationElement>;
+    getColors(stepData: Step<IllustrationStepData>, workflowManager: WorkflowManager): never[] | {
+        [key: string]: ColorDefinition;
+    };
+    init(stepData: Step<IllustrationStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    availableColors(stepData: Step<IllustrationStepData>, _workflowManager: WorkflowManager): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: VariantResource;
+    }[] | undefined>;
+    changeColorsCommand(svg: string, illustrationWidth: number, illustrationHeight: number, elements: string[], newFills: Map<string, string>): Promise<CanvasCommand>;
+    changeColors(stepData: Step<IllustrationStepData>, elements: RegionElement[], workflowManager: WorkflowManager, getAllLayouts: () => LayoutData[], newFills: Map<string, string>): Promise<void>;
+    selectVariant(stepData: Step<IllustrationStepData>, variant: VariantResource, elements: RegionElement[], setIsUpdating: (isUpdating: boolean) => void, workflowManager: WorkflowManager): Promise<void>;
+    private selectVariantCommand;
+}
+declare const illustrationStepService: IllustrationStepService;
+
+declare class MaterialStepService implements StepService<MaterialStepData> {
+    init(stepData: Step<MaterialStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<null | CommandWithFollowup>;
+    private reload;
+    selectVariant(step: Step<MaterialStepData>, variant: VariantResource, workflowManager: WorkflowManager, setApplying: (status: boolean) => void): Promise<void>;
+    private selectVariantLambda;
+}
+declare const materialStepService: MaterialStepService;
+
+declare class ModelStepService implements StepService<ModelStepData> {
+    init(stepData: Step<ModelStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    selectVariant(step: Step<ModelStepData>, variant: VariantResource, workflowManager: WorkflowManager, setApplying: (status: boolean) => void): Promise<void>;
+    private selectVariantLambda;
+}
+declare const modelStepService: ModelStepService;
+
+interface TextFillSpotColor {
+    profileName: string;
+    namedColor: string;
+}
+interface TextUpdateResult {
+    command?: GroupCommand;
+    helperText: string;
+    errors: TextError[];
+}
+interface TextError {
+    localizationKey: string;
+}
+declare class TextStepService implements StepService<TextStepData> {
+    private cachedColors;
+    init(stepData: Step<TextStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    findLayoutElements(workflowManager: WorkflowManager, step: Step<TextStepData>): TextboxElement[];
+    /**
+     * Get the colors that can be used for a given text step.
+     * @param stepData The text step to get colors for.
+     * @returns A list of color objects containg fill, stroke and variant if available.
+     */
+    availableFillColors(stepData: Step<TextStepData>): ColorOption[];
+    changeAlignment(stepData: Step<TextStepData>, alignment: "left" | "center" | "right", elements: RegionElement[], workflowManager: WorkflowManager): void;
+    changeFillColor(stepData: Step<TextStepData>, newColor: ColorOption, elements: RegionElement[], workflowManager: WorkflowManager): Promise<void>;
+    availableFillImages(stepData: Step<TextStepData>): Promise<TextFillImage[]>;
+    changeFillImage(stepData: Step<TextStepData>, fillImage: TextFillImage, elements: RegionElement[], workflowManager: WorkflowManager): Promise<void>;
+    /**
+     * Given an element and a string, filters any characters from the string that are
+     * not supported by the font of the given element.
+     * @param text The text string to filter.
+     * @param fontData An optional fontData object, when provided, we use the font table to determine glyphs that aren't provided and additionally strip these out also.
+     * @returns A new string representing the passed string with unsupported characters removed.
+     */
+    filterUnsupportedCharacters: (text: string, fontData?: FontData) => string;
+    getProcessedInput(input: string, stepData: TextStepData, customiseAllText: boolean): string;
+    updateInputText(input: string, elements: TextboxElement[], step: Step<TextStepData>, workflowManager: WorkflowManager): TextUpdateResult;
+    selectVariant(step: Step<TextStepData>, variant: VariantResource, workflowManager: WorkflowManager, setError: (status: boolean) => void, setHelperText: (text: string) => void): Promise<void>;
+    textAlign: (stepData: TextStepData) => string;
+    createTextFillSpotColor(colorOption: OptionResource, variant: VariantResource): TextFillSpotColor | undefined;
+    private reload;
+    private getDefaultColorVariant;
+    private getDefaultColor;
+    private getDefaultImageFillVariant;
+    /**
+     * Validates a string of text based on step confoiguration.
+     * @param text The text to validate
+     * @param step The step providing configuration
+     * @param workflowManager Workflow manager for access to workflow state
+     * @returns A list of errors. Empty if the text passes validation.
+     */
+    private getErrorsForText;
+    private fontDataFromVariant;
+    private selectVariantCommand;
+    /**
+     * When a text step specifies replaceable text, the text input by the user will replace
+     * a specific token within a larger string of text specified in the step configuration. Otherwise
+     * this function will just return the text it's given when the feature is disabled.
+     */
+    private injectReplaceableText;
+    private createTextboxRegions;
+    private generateTextChangeCommandsForRegion;
+    /**
+     * @deprecated
+     */
+    private changeInputTextWithRegion;
+}
+declare const textStepService: TextStepService;
+
+declare class PictureStepService implements StepService<PictureStepData> {
+    init(stepData: Step<PictureStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    selectVariant(stepData: Step<PictureStepData>, variant: VariantResource, workflowManager: WorkflowManager, setIsUpdating: (status: boolean) => void): Promise<void>;
+    private selectVariantCommand;
+}
+declare const pictureStepService: PictureStepService;
+
+declare class QuestionStepService implements StepService<QuestionStepData> {
+    init(stepData: Step<QuestionStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    selectVariant(stepData: Step<QuestionStepData>, variantId: string, workflowManager: WorkflowManager): Promise<void>;
+    private selectVariantLambda;
+}
+declare const questionStepService: QuestionStepService;
+
+declare class ShapeStepService implements StepService<ShapeStepData> {
+    readonly shapeFillId = "spiff-fill-shape";
+    availableColours(stepData: Step<ShapeStepData>): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: VariantResource;
+    }[]>;
+    setCustomColor(color: string, stepData: Step<ShapeStepData>, manager: WorkflowManager): void;
+    init(stepData: Step<ShapeStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    selectVariant(stepData: Step<ShapeStepData>, colourOption: ColorOption, elements: RegionElement[], workflowManager: WorkflowManager): Promise<void>;
+    private reload;
+    private selectVariantCommand;
+}
+declare const shapeStepService: ShapeStepService;
+
+declare class ModuleStepService implements StepService<ModuleStepData> {
+    init(stepData: Step<ModuleStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    changeText(stepData: Step<ModuleStepData>, input: string, workflowManager: WorkflowManager, error: string, setError: (e: string) => void): Promise<void>;
+    private changeTextCommand;
+    private validateInput;
+}
+declare const moduleStepService: ModuleStepService;
+
+declare class DigitalContentStepService implements StepService<DigitalContentStepData> {
+    init(stepData: Step<DigitalContentStepData>, workflowManager: WorkflowManager, reducerState?: LayoutsState): Promise<CommandWithFollowup | null>;
+    private reload;
+    regenerateQRCode(elements: RegionElement[], uploading: boolean, assetKey: string, url: string, workflowManager: WorkflowManager, stepData: Step<DigitalContentStepData>, setUrl: (finalUrl: string) => void, commandDispatcher: (command: CanvasCommand) => void, setIsRegenerating: (state: boolean) => void): Promise<void>;
+    private regionElements;
+    private command;
+}
+declare const digitalContentStepService: DigitalContentStepService;
+
+declare class MockWorkflowManager implements WorkflowManager {
+    private client;
+    getClient(): SpiffCommerceClient;
+    setClient(client: SpiffCommerceClient): void;
+    getInitializationPromise(): Promise<void>;
+    getProduct: () => Product;
+    isInitialized(): boolean;
+    getCommandContext: () => CommandContext;
+    getAllLayoutData: () => LayoutState[];
+    getMetadata: (stepName: string) => StepMetadata | undefined;
+    getWorkflowMetadata: () => WorkflowMetadata;
+    getStepStorage: (stepName: string) => StepStorage | undefined;
+    getInformationResults(): InformationResult[];
+    reset(): Promise<void>;
+    updateStateWithServer(_getReducerState: () => CommandState): void;
+    outstandingRequestsPromise(): Promise<void>;
+    updateStateWithServerImmediate(_getReducerState: () => CommandState): Promise<void>;
+    addPoller(_poller: Poller): void;
+    addConfirmCallback(_callback: ConfirmCallback): void;
+    addEditedCallback(_callback: EditedCallback): void;
+    addElementsCallback(_callback: ElementsCallback): void;
+    addInformationResultCallback(_callback: InformationResultCallback): void;
+    addInitCallback(_callback: InitCallback): void;
+    addMakingAdjustmentsCallback(_callback: MakingAdjustmentsCallback): void;
+    addMandatoryCallback(_callback: MandatoryCallback): void;
+    addMetadataCallback(_callback: MetadataCallback): void;
+    addSelectionCallback(_callback: SelectionCallback): void;
+    addStepSpecificStorageCallback(_callback: StepSpecificStorageCallback, _stepName: string): void;
+    addStorageCallback(_callback: StorageCallback): void;
+    getCommandDispatcher(): (_command: CanvasCommand) => void;
+    getLayouts(): never[];
+    getLayoutPreviewService(): any;
+    getPreviewService(): undefined;
+    setModelContainer: (container: any) => void;
+    getModelContainer(): undefined;
+    getProfanities(): never[];
+    getRegionElements(_stepName: string): never[];
+    getSerializedStep(_stepName: string, _serializedSteps: SerializableStep[]): undefined;
+    getStepSpecificServices(_stepName: string): undefined;
+    getTransaction(): {
+        id: string;
+    };
+    getTransactionCustomer(): undefined;
+    setTransactionCustomer(): void;
+    setTransactionCustomerDetails(): void;
+    getWorkflow(): {
+        id: string;
+        name: string;
+        panels: never[];
+        steps: never[];
+        showModelOnFinishStep: boolean;
+        allowProofDownload: boolean;
+        introduction: string;
+        stepGroups: never[];
+    };
+    markStepsAsInitialised(_stepNames: string[]): void;
+    getUpdatesPending: () => boolean;
+    markUpdateCompleted(_update: string): void;
+    markUpdatePending(): string;
+    getWorkflowSelections(): {};
+    setCurrentAdjustingStepId(_stepId: string): void;
+    setEditedStatus(_stepName: string, _status: boolean): void;
+    setInformationResults(_results: InformationResult[]): void;
+    setMandatoryFulfilled(_stepName: string, _status: boolean): void;
+    setSelectionsAndElements(_stepName: string, _variants: VariantResource[], _elements: RegionElement[]): Promise<void>;
+    toggleDesignConfirmed(): void;
+    updateMetadata(_stepName: string, _update: any): void;
+    updateStorage(_stepName: string, _update: StepStorage): Promise<void>;
+    injectIntoPreviewService(_previewService: any): Promise<void>;
+    ejectFromPreviewService(): void;
+    setWorkflowStateSyncEnabled(_enabled: boolean): void;
+    updateTransactionShareActions(): Promise<void>;
+}
+
+declare const generateCommands: (designInputSteps: DesignInputStep[], workflow: Workflow, layouts: ILayout[], productOverlayImageUrl?: string) => Promise<CanvasCommand[]>;
+
+declare class IllustrationStepHandle extends StepHandle<IllustrationStepData> {
+    constructor(manager: WorkflowManager, step: Step<IllustrationStepData>);
+    /**
+     * Allows for select a vector from the available vectors configured on this steps base option.
+     * @param variant The new vector variant to use for this step.
+     * @returns A promise that can be awaited to know when the new vector asset has been updated on the design.
+     */
+    selectVariant(variant: Variant): Promise<void>;
+    /**
+     * Get colors for the illustration.
+     * @returns A list of color definitions that are currently applied to the illustration.
+     */
+    getColors(): {
+        [key: string]: _spiffcommerce_papyrus.ColorDefinition;
+    } | undefined;
+    /**
+     * Set color for the illustration.
+     */
+    setColor(key: string, value: string): Promise<void>;
+    getColorOption(): Promise<_spiffcommerce_papyrus.OptionResource | undefined>;
+    getAvailableColors(): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: _spiffcommerce_papyrus.VariantResource;
+    }[] | undefined>;
+    isColorPickerEnabled(): boolean | undefined;
+}
+
+interface TextChangeResult {
+    input: string;
+    helperText?: string;
+    errorText?: string;
+}
+declare class TextStepHandle extends StepHandle<TextStepData> {
+    constructor(manager: WorkflowManager, step: Step<TextStepData>);
+    /**
+     * Allows for select a font from the available fonts configured on this steps base option.
+     * @param variant The font variant to use.
+     */
+    selectVariant(variant: Variant): Promise<void>;
+    /**
+     * @returns A list of colors that can be used to fill the text.
+     */
+    getAvailableFillColors(): ColorOption[];
+    /**
+     * Changes the fill of text related to this step to the new fill value.
+     * @param fill A new fill value to use.
+     */
+    setFillColor(fill: ColorOption): Promise<void>;
+    /**
+     * Gets the color currently applied to the element.
+     */
+    getFillColor(): string;
+    getAvailableFillImages(): Promise<TextFillImage[]>;
+    setFillImage(fillImage: TextFillImage): Promise<void>;
+    getFillImage(): TextFillImage | undefined;
+    getAlignment(): string | undefined;
+    setAlignment(alignment: "left" | "center" | "right"): void;
+    /**
+     * When true & the step has replaceable text configured the user will be
+     * abled to edit the entire text string including the non-replaceable text.
+     * @param shouldCustomizeAll When true the user can configure the entire text string.
+     */
+    setFullTextCustomization(shouldCustomizeAll: boolean): TextChangeResult;
+    /**
+     * Changes the text value of text related to this step to a new value.
+     * @param userInput Input from the user.
+     */
+    setText(userInput: string): TextChangeResult;
+    /**
+     * Gets the text currently applied to the elements of this step.
+     */
+    getText(): string;
+    isReplaceable(): boolean | undefined;
+    /**
+     * Inform the step that now is the time to
+     * clear default text if it should do so.
+     * Returns a text change rwsult if a clear occurred.
+     */
+    clearDefaultTextIfNecessary(): TextChangeResult | undefined;
+    hasColorPicker(): boolean | undefined;
+    getRegions(): _spiffcommerce_papyrus.Region[];
+    /**
+     * Return the maximum characters allowed for
+     * this step, or undefined if there is no limit.
+     */
+    getCharacterLimit(): number | undefined;
+    /**
+     * Return the remaining amount of characters that
+     * the user is allowed to add, or undefined if there is no limit.
+     */
+    getCharactersRemaining(): number | undefined;
+}
+
+declare class PictureStepHandle extends StepHandle<PictureStepData> {
+    constructor(manager: WorkflowManager, step: Step<PictureStepData>);
+    /**
+     * Allows the user to select an image variant from the available variants configured on this steps base option.
+     * @param variant The new image variant to use.
+     * @returns A promise that can be awaited to ensure the new image asset has been updated on the design.
+     */
+    selectVariant(variant: Variant): Promise<void>;
+}
+
+/**
+ * A generic base class for custom errors that assigns the name
+ * of the error class automatically. All custom errors should extend this.
+ */
+declare abstract class CustomError extends Error {
+    constructor(message: any);
+}
+/**
+ * A custom class for categorising errors related to workflow configuration.
+ */
+declare abstract class ConfigurationError extends CustomError {
+    constructor(message: any);
+}
+/**
+ * Thrown when an option was expected but not found in the workflow configuration or
+ * the server returned a 404 for an option we expected.
+ */
+declare class OptionNotFoundError extends ConfigurationError {
+    readonly optionId: string;
+    constructor(step: Step<AnyStepData>);
+}
+/**
+ * Thrown when a layout is not found for a given region entity. This
+ * can occur when panels are deleted from a workflow but steps are still relying
+ * on the layout being present.
+ */
+declare class LayoutNotFoundError extends ConfigurationError {
+    readonly panelId: string;
+    constructor(region: Region);
+}
+/**
+ * Thrown when an asset is not found on a specific variant. This can occur when
+ * the asset wasn't configured in hub and the variant is loaded in a workflow.
+ */
+declare class AssetNotFoundError extends ConfigurationError {
+    readonly variant: VariantResource;
+    constructor(variant: VariantResource);
+}
+/**
+ * Thrown when a resource is not found linked to a specific asset. This
+ * can occur when generation of a resource fails or hasn't completed. Or may be
+ * a sign of a misconfiguration.
+ */
+declare class ResourceNotFoundError extends ConfigurationError {
+    readonly asset: Asset;
+    constructor(asset: Asset);
+}
+/**
+ * Thrown when configuration is missing when it was expected. More generic
+ * to cover remaining cases outside of the more specific ones such as options, variants & assets.
+ */
+declare class MisconfigurationError extends ConfigurationError {
+    readonly step: Step<AnyStepData>;
+    constructor(step: Step<AnyStepData>, message: string);
+}
+/**
+ * A custom class for categorising errors related to implementation of core.
+ */
+declare abstract class ImplementationError extends CustomError {
+    constructor(message: any);
+}
+/**
+ * Thrown when we hit a case that we didn't expect to happen
+ */
+declare class UnhandledBehaviorError extends ImplementationError {
+    constructor(message: string);
+}
+/**
+ * Thrown when we fail to parse something that we expected to be valid
+ */
+declare class ParseError extends ImplementationError {
+    constructor(message: string);
+}
+
+declare class ModelStepHandle extends StepHandle<ModelStepData> {
+    constructor(manager: WorkflowManager, step: Step<ModelStepData>);
+    selectVariant(variant: Variant): Promise<void>;
+}
+
+declare enum FrameStep {
+    SelectFrame = "SelectFrame",
+    SelectImage = "SelectImage",
+    Position = "Position"
+}
+declare class FrameStepHandle extends StepHandle<FrameStepData> {
+    constructor(manager: WorkflowManager, step: Step<FrameStepData>);
+    private frameService;
+    selectVariant(variant: Variant): Promise<void>;
+    onFrameDataChanged(callback: (frameData: FrameData$1[]) => void): void;
+    /**
+     * Updates the image selection inside the frame.
+     * @param asset The asset to use.
+     * @param storeAsOriginal Optional: Store this asset as the original, unmodified version of the image. Default: `true`.
+     * @param [recalculateOffsets=true] Optional: Recalculates the offsets of the image inside the frame. Default: `true`.
+     */
+    selectImage(asset: Asset, storeAsOriginal?: boolean, recalculateOffsets?: boolean): Promise<void>;
+    canUseBackgroundRemover(): Promise<boolean>;
+    /**
+     * Removes the background from an image, stores it in the state, and returns the new asset.
+     * @param applyNewAsset Optionally applies the new asset as the current image selection. Default: `true`.
+     * @returns A promise that resolves with the newly generated Asset.
+     */
+    removeBackgroundFromImageSelection(applyNewAsset?: boolean): Promise<Asset>;
+    getImageData(): PatternImageData | undefined;
+    getCurrentFrameStep(frameData: FrameData$1, uploading?: any, imageUploadComplete?: any, variants?: VariantResource[]): FrameStep;
+    getFrameService(): FrameService | undefined;
+    hasOverlayImageKey(): string | undefined;
+    hasOverlayImageUrl(): any;
+    getOriginalImageSelection(): Promise<Asset | undefined>;
+    getBackgroundRemovedImageSelection(): Promise<Asset | undefined>;
+    hasBackgroundRemovedImageSelection(): boolean;
+    getUseOriginalImageSelection(): boolean;
+    setUseOriginalImageSelection(value: boolean): Promise<void>;
+    private getFrameStepStorage;
+}
+
+declare class MaterialStepHandle extends StepHandle<MaterialStepData> {
+    constructor(manager: WorkflowManager, step: Step<MaterialStepData>);
+    selectVariant(variant: Variant): Promise<void>;
+}
+
+declare class QuestionStepHandle extends StepHandle<QuestionStepData> {
+    constructor(manager: WorkflowManager, step: Step<QuestionStepData>);
+    selectVariant(variant: Variant): Promise<void>;
+    /**
+     * The way that this step expects to be rendered.
+     */
+    getDisplayType(): any;
+}
+
+declare class ShapeStepHandle extends StepHandle<ShapeStepData> {
+    constructor(manager: WorkflowManager, step: Step<ShapeStepData>);
+    selectVariant(variant: Variant): Promise<void>;
+    /**
+     * Sets the color of the shape.
+     * @param color The color option to use.
+     * @returns A promise resolving when the color has changed in the design.
+     * @deprecated The shape step can now pass through colors returned by getColors via selectVariant. Please swap setColor for selectVariant.
+     */
+    setColor(color: ColorOption): Promise<void>;
+    /**
+     * Get available colors for the shape.
+     * @returns A list of color definitions that are currently applied to the illustration.
+     */
+    getColors(): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: _spiffcommerce_papyrus.VariantResource;
+    }[]>;
+    /**
+     * Allows for setting a custom color when the custom variant is selected. Will
+     * throw when a non-custom variant is selected.
+     */
+    setCustomColor(color: string): void;
+    getCustomColor(): string;
+}
+
+declare const shortenUrl: (longUrl: string) => Promise<string>;
+
+declare class InformationStepHandle extends StepHandle<InformationStepData> {
+    constructor(manager: WorkflowManager, step: Step<InformationStepData>);
+    selectVariant(): Promise<void>;
+    /**
+     * The way that this step expects to be rendered.
+     */
+    getContent(): string;
+}
+
+/**
+ * A simple cache for promises. Helpful to avoid making multiple requests for the same data.
+ */
+declare class PromiseCache {
+    private cache;
+    private disabled;
+    /**
+     * Gets a promise from the cache, or undefined if it doesn't exist.
+     */
+    get(key: object): Promise<any> | undefined;
+    /**
+     * Sets a promise in the cache and returns it.
+     */
+    set(key: object, promise: Promise<any>): Promise<any>;
+    /**
+     * Some environments don't want workflows to be cached. An example is a server
+     * that doesn't launch a fresh instance per request. This method allows disabling
+     * caching in a transparent way.
+     */
+    disable(value: boolean): void;
+}
+declare const promiseCache: PromiseCache;
+
+export { AddonHandle, ArrayInput, AssetNotFoundError, Bundle$1 as Bundle, BundleDesignCreationMessage, BundleEvent, BundleEventData, BundleEventType, CollectionProduct, ColorOption, ColorOptionGlobalPropertyHandle, ConditionalGlobalPropertiesChangedEventData, ConversionConfiguration, ConversionData, ConversionDataType, ConversionLocation, Customer, CustomerDetailsInput, DesignCreationMessage, DesignCreationProgressUpdate, DesignInputStep, EditedSteps, FileUploadGlobalPropertyHandle, FlowExecutionNodeResult, FlowExecutionResult, FlowService, FrameService, FrameStep, FrameStepHandle, FrameThresholdSettings, GetNewWorkflowOptions, GetWorkflowOptions, GlobalPropertyHandle, IllustrationStepHandle, InformationMessageType, InformationResult, InformationStepHandle, IntegrationProduct, IntegrationType, LayoutNotFoundError, MandatorySteps, MaterialStepHandle, MisconfigurationError, MockWorkflowManager, ModelStepHandle, NodeType, ObjectInput, ObjectInputType, OptionGlobalPropertyHandle, OptionNotFoundError, ParseError, PictureStepHandle, Product, ProductCameraRig, ProductCollection, ProductWorkflow$1 as ProductWorkflow, promiseCache as PromiseCache, PromiseQueue, QuestionStepHandle, QueueablePromise, RegionElement, RenderableScene, ResourceNotFoundError, SavedDesign, SelectionStorage, ShapeStepHandle, SilentIllustrationStepData, SpiffCommerceClient, Stakeholder, StakeholderType, StateMutationFunc, StepElements, StepHandle, TextGlobalPropertyHandle, TextInput, TextStepHandle, TextStepStorage, ToastCallback, Transaction, Transform, TransformCollection$1 as TransformCollection, UnhandledBehaviorError, Variant, Vector3, WorkflowExperience, WorkflowExperienceEventType, WorkflowExperienceHoverEventData, WorkflowExperienceImpl, WorkflowManager, WorkflowMetadata, WorkflowScene, WorkflowSelections, WorkflowStorage, assetService, createDesign, designService, digitalContentStepService, frameStepService, generateCommands, generateStateFromDesignInputSteps, getBoundedOffsets, getWorkflow, getWorkflows, graphQlManager, illustrationStepService, materialStepService, modelStepService, moduleStepService, optionService, persistenceService, pictureStepService, questionStepService, setBearerAuthenticationToken, shapeStepService, shortenUrl, spiffCoreConfiguration, stepAspectValuesToDesignInputSteps, textStepService, toast };