@spiffcommerce/core 14.2.1-alpha.0 → 14.2.2

package/dist/types.d.ts

@@ -0,0 +1,2385 @@
+import { Workflow as _Workflow1, StepAspect as _StepAspect1, Step as _Step1, AnyStepData as _AnyStepData1, Asset as _Asset1, Region, VariantResource as _VariantResource1, FrameOffsets, PatternImageData, DigitalContentStepData as _DigitalContentStepData1, LayoutsState as _LayoutsState1, CanvasCommand as _CanvasCommand1, FrameStepData as _FrameStepData1, ILayout as _ILayout1, CreateElementCommand as _CreateElementCommand1, FrameElement as _FrameElement1, ColorDefinition as _ColorDefinition1, IllustrationStepData as _IllustrationStepData1, IllustrationElement as _IllustrationElement1, LayoutData as _LayoutData1, MaterialStepData as _MaterialStepData1, ModelStepData as _ModelStepData1, ModuleStepData as _ModuleStepData1, PictureStepData as _PictureStepData1, QuestionStepData as _QuestionStepData1, ShapeStepData as _ShapeStepData1, FontData, GroupCommand as _GroupCommand1, OptionResource as _OptionResource1, TextboxElement as _TextboxElement1, TextFillImage, TextStepData as _TextStepData1, StepStorage as _StepStorage1, SerializableStep, CommandState as _CommandState1, CommandContext as _CommandContext1, LayoutState, GlobalPropertyConfiguration, MaterialResource, AssetType as _AssetType1, Point, ScaleAxis, UnitOfMeasurement as _UnitOfMeasurement1, StepType as _StepType1, BulkStepData as _BulkStepData1, FrameData as _FrameData1, AspectType, GlobalPropertyConfigurationAspect, Theme as _Theme1, Animatable, AnyStepData, Asset, AssetType, BringForwardCommand, BringToFrontCommand, BringToBackCommand, BulkStepData, CanvasCommand, ColorDefinition, CommandContext, CommandState, CreateElementCommand, DeleteElementCommand, DigitalContentStepData, FontAlignmentCommand, FontColorCommand, FontSizeCommand, FontSourceCommand, FrameElement, FrameStepData, GroupCommand, ILayout, IllustrationElement, IllustrationStepData, ImageElement, LayoutData, LayoutElement, LayoutElementFactory, LayoutElementType, LayoutsState, MaterialStepData, ModelStepData, ModuleStepData, MoveCommand, OptionResource, PictureStepData, QuestionStepData, ResizeCommand, RotateCommand, SendBackwardsCommand, ShapeStepData, Step, StepAspect, StepAspectType, StepStorage, StepType, TextChangeCommand, TextStepData, TextboxElement, UnitOfMeasurement, VariantResource, Workflow, dataUrlFromExternalUrl, findElement, frameDataCache, generate, generateSVGWithUnknownColors, getAttributesFromArrayBuffer, getFrameData, getSvgElement, loadFontFromDataUrl, loadFontFromExternalUrl, patternImageDataCache, CreateLayoutCommand, rehydrateSerializedLayout, ColorProfileProps, WorkflowPanel, determineCorrectFontSizeAndLines, registerJSDOM, getAxisAlignedBoundingBox, Theme } from "@spiffcommerce/papyrus";
+import { ApolloClient } from "@apollo/client";
+import React, { ReactNode, Dispatch, FunctionComponent, RefObject, PointerEvent, KeyboardEvent } from "react";
+export const gatherVaryingStepAspects: (workflow: _Workflow1) => _StepAspect1[];
+/**
+ * A renderable scene is a scene that can be displayed to the user. This is based on the workflow state.
+ */
+export 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[];
+}
+/**
+ * Information parsed froma workflow structure that is relevant
+ * to a given scene.
+ */
+export 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: _Step1<_AnyStepData1>[];
+    /**
+     * Steps which don't display to the user.
+     * Their behavior is always silent & executed in the background.
+     */
+    silentSteps: _Step1<_AnyStepData1>[];
+}
+/**
+ * A queue promise is a container for a promise that can be
+ * executed at a later time.
+ */
+export 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.
+ */
+export class PromiseQueue<T extends QueueablePromise> {
+    /**
+     * Constructs a new promise queue.
+     * @param queueMaxSize An optional maximum size, when the max size is hit.
+     *                     The older promises will be discarded.
+     */
+    constructor(queueMaxSize?: number);
+    /**
+     * Enqueue a new promise.
+     * @param promise A new promise to add to the queue.
+     */
+    enqueue(promise: T): void;
+    /**
+     * @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>;
+}
+/**
+ * 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.
+ */
+export class OptionNotFoundError extends ConfigurationError {
+    readonly optionId: string;
+    constructor(step: _Step1<_AnyStepData1>);
+}
+/**
+ * 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.
+ */
+export 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.
+ */
+export class AssetNotFoundError extends ConfigurationError {
+    readonly variant: _VariantResource1;
+    constructor(variant: _VariantResource1);
+}
+/**
+ * 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.
+ */
+export class ResourceNotFoundError extends ConfigurationError {
+    readonly asset: _Asset1;
+    constructor(asset: _Asset1);
+}
+/**
+ * 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.
+ */
+export class MisconfigurationError extends ConfigurationError {
+    readonly step: _Step1<_AnyStepData1>;
+    constructor(step: _Step1<_AnyStepData1>, 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
+ */
+export class UnhandledBehaviorError extends ImplementationError {
+    constructor(message: string);
+}
+/**
+ * Thrown when we fail to parse something that we expected to be valid
+ */
+export class ParseError extends ImplementationError {
+    constructor(message: string);
+}
+/**
+ * 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.
+ */
+export function getBoundedOffsets(newOffsets: FrameOffsets, frameData: FrameData, imageData: PatternImageData, mustCover?: boolean): FrameOffsets;
+export class FrameService {
+    /**
+     * 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[];
+    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
+     */
+    setPatternData(value: PatternImageData): 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;
+    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;
+}
+declare class Poller {
+    /**
+     * 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 class Configuration {
+    constructor();
+    getServerUrl(): string;
+    getServicesApiUrl(): string;
+    getHubUrl(): string;
+    setServerUrl(serverUrl: string): void;
+    setServicesApiUrl(servicesApiUrl: string): void;
+    setHubUrl(hubUrl: string): void;
+    addServerUrlCallback(callback: () => void): void;
+}
+export const spiffCoreConfiguration: Configuration;
+export const shortenUrl: (longUrl: string) => Promise<string>;
+declare class DigitalContentStepService implements StepService<_DigitalContentStepData1> {
+    init(stepData: _Step1<_DigitalContentStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    regenerateQRCode(elements: RegionElement[], uploading: boolean, assetKey: string, url: string, workflowManager: WorkflowManager, stepData: _Step1<_DigitalContentStepData1>, setUrl: (finalUrl: string) => void, commandDispatcher: (command: _CanvasCommand1) => void, setIsRegenerating: (state: boolean) => void): Promise<void>;
+}
+export const digitalContentStepService: DigitalContentStepService;
+interface FrameCreateOpts {
+    stepName?: string;
+    frameData: FrameData;
+    disablePlaceholder?: boolean;
+    focalBlur?: boolean;
+    focalBlurStrength?: number;
+    focalBlurRadius?: number;
+    pattern?: any;
+}
+declare class FrameStepService implements StepService<_FrameStepData1> {
+    init(stepData: _Step1<_FrameStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    selectImage(stepData: _Step1<_FrameStepData1>, asset: _Asset1, workflowManager: WorkflowManager): void;
+    selectVariant(stepData: _Step1<_FrameStepData1>, variant: _VariantResource1 | undefined, elements: RegionElement[], workflowManager: WorkflowManager, setFrameIsUpdating?: (status: boolean) => void): Promise<void>;
+    getCreateElementCommand(id: string, region: Region, layout: _ILayout1, options: FrameCreateOpts): _CreateElementCommand1<_FrameElement1>;
+    loadPatternFromString(src: string, frameService: FrameService): Promise<void>;
+}
+export const frameStepService: FrameStepService;
+interface SVGCreateOpts {
+    stepName?: string;
+    src: string;
+    objectURL: string;
+    svg: {
+        svg: string;
+        colors: {
+            [key: string]: _ColorDefinition1;
+        };
+    };
+}
+declare class IllustrationStepService implements StepService<_IllustrationStepData1> {
+    getIllustrationBody(src: string): Promise<string>;
+    getCreateElementCommand(id: string, region: Region, layout: _ILayout1, options: SVGCreateOpts): _CreateElementCommand1<_IllustrationElement1>;
+    getColors(stepData: _Step1<_IllustrationStepData1>, workflowManager: WorkflowManager): {
+        [key: string]: _ColorDefinition1;
+    } | never[];
+    init(stepData: _Step1<_IllustrationStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    availableColors(stepData: _Step1<_IllustrationStepData1>, workflowManager: WorkflowManager): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: _VariantResource1;
+    }[] | undefined>;
+    changeColorsCommand(svg: string, illustrationWidth: number, illustrationHeight: number, elements: string[], newFills: Map<string, string>): Promise<_CanvasCommand1>;
+    changeColors(stepData: _Step1<_IllustrationStepData1>, elements: RegionElement[], workflowManager: WorkflowManager, getAllLayouts: () => _LayoutData1[], newFills: Map<string, string>): Promise<void>;
+    selectVariant(stepData: _Step1<_IllustrationStepData1>, variant: _VariantResource1, elements: RegionElement[], setIsUpdating: (isUpdating: boolean) => void, workflowManager: WorkflowManager): Promise<void>;
+}
+export const illustrationStepService: IllustrationStepService;
+declare class MaterialStepService implements StepService<_MaterialStepData1> {
+    init(stepData: _Step1<_MaterialStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<null | CommandWithFollowup>;
+    selectVariant(step: _Step1<_MaterialStepData1>, variant: _VariantResource1, workflowManager: WorkflowManager, setApplying: (status: boolean) => void): Promise<void>;
+}
+export const materialStepService: MaterialStepService;
+declare class ModelStepService implements StepService<_ModelStepData1> {
+    init(stepData: _Step1<_ModelStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    selectVariant(step: _Step1<_ModelStepData1>, variant: _VariantResource1, workflowManager: WorkflowManager, setApplying: (status: boolean) => void): Promise<void>;
+}
+export const modelStepService: ModelStepService;
+declare class ModuleStepService implements StepService<_ModuleStepData1> {
+    init(stepData: _Step1<_ModuleStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    changeText(stepData: _Step1<_ModuleStepData1>, input: string, workflowManager: WorkflowManager, error: string, setError: (e: string) => void): Promise<void>;
+}
+export const moduleStepService: ModuleStepService;
+declare class PictureStepService implements StepService<_PictureStepData1> {
+    init(stepData: _Step1<_PictureStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    selectVariant(stepData: _Step1<_PictureStepData1>, variant: _VariantResource1, workflowManager: WorkflowManager, setIsUpdating: (status: boolean) => void): Promise<void>;
+}
+export const pictureStepService: PictureStepService;
+declare class QuestionStepService implements StepService<_QuestionStepData1> {
+    init(stepData: _Step1<_QuestionStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    selectVariant(stepData: _Step1<_QuestionStepData1>, variantId: string, workflowManager: WorkflowManager): Promise<void>;
+}
+export const questionStepService: QuestionStepService;
+declare class ShapeStepService implements StepService<_ShapeStepData1> {
+    availableColours(stepData: _Step1<_ShapeStepData1>): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: _VariantResource1;
+    }[]>;
+    init(stepData: _Step1<_ShapeStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    selectVariant(stepData: _Step1<_ShapeStepData1>, colourOption: ColorOption, elements: RegionElement[], workflowManager: WorkflowManager): Promise<void>;
+}
+export const shapeStepService: ShapeStepService;
+type ToastCallback = (callbackOptions: {
+    toastMessage: null | string;
+    toastType: InformationMessageType | null;
+}) => void;
+declare class Toast {
+    constructor();
+    addToastCallback(callback: ToastCallback): void;
+    setLatestToast(errorMessage: null | string, errorType: InformationMessageType | null): void;
+}
+export const toast: Toast;
+interface TextFillSpotColor {
+    profileName: string;
+    namedColor: string;
+}
+interface TextUpdateResult {
+    command?: _GroupCommand1;
+    helperText: string;
+    errors: TextError[];
+}
+interface TextError {
+    localizationKey: string;
+}
+declare class TextStepService implements StepService<_TextStepData1> {
+    init(stepData: _Step1<_TextStepData1>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): Promise<CommandWithFollowup | null>;
+    findLayoutElements(workflowManager: WorkflowManager, step: _Step1<_TextStepData1>): _TextboxElement1[];
+    /**
+     * 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: _Step1<_TextStepData1>): ColorOption[];
+    changeFillColor(stepData: _Step1<_TextStepData1>, newColor: ColorOption, elements: RegionElement[], workflowManager: WorkflowManager): Promise<void>;
+    availableFillImages(stepData: _Step1<_TextStepData1>): Promise<TextFillImage[]>;
+    changeFillImage(stepData: _Step1<_TextStepData1>, 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: _TextStepData1, customiseAllText: boolean): string;
+    updateInputText(input: string, elements: _TextboxElement1[], step: _Step1<_TextStepData1>, workflowManager: WorkflowManager): TextUpdateResult;
+    selectVariant(step: _Step1<_TextStepData1>, variant: _VariantResource1, workflowManager: WorkflowManager, setError: (status: boolean) => void, setHelperText: (text: string) => void): Promise<void>;
+    textAlign: (stepData: _TextStepData1) => string;
+    createTextFillSpotColor(colorOption: _OptionResource1, variant: _VariantResource1): TextFillSpotColor | undefined;
+}
+export const textStepService: TextStepService;
+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;
+}
+export interface EditedSteps {
+    [stepName: string]: boolean;
+}
+export interface MandatorySteps {
+    [stepName: string]: boolean;
+}
+export type StepElements = {
+    [key: string]: RegionElement[];
+};
+type StepInitialised = {
+    [key: string]: boolean;
+};
+type StepMetadata = FrameMetadata | IllustrationMetadata | ModuleMetadata | TextMetadata;
+export interface WorkflowStorage {
+    [stepName: string]: _StepStorage1;
+}
+export interface WorkflowMetadata {
+    [stepName: string]: StepMetadata;
+}
+export interface WorkflowSelections {
+    [stepName: string]: {
+        selections: _VariantResource1[];
+    };
+}
+export interface InformationResult {
+    message: string;
+    messageType: InformationMessageType;
+    stepID: string;
+}
+export enum InformationMessageType {
+    Error = "Error",
+    Warning = "Warning",
+    Info = "Info"
+}
+/**
+ * Services required for the operaiton of individual steps.
+ */
+interface StepSpecificServices {
+    frameService?: FrameService;
+    module?: ModuleProduct;
+}
+export 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: {
+    invalidModelVariants: string[];
+    selectionCost: number;
+    selections: StepSelections;
+    traversableScenes: WorkflowScene[];
+}) => void;
+type StepSpecificStorageCallback = (selections: _StepStorage1) => void;
+type StorageCallback = (storage: WorkflowStorage) => void;
+type CurrentVariationRecordCallback = (variationRecord: null | VariationRecord) => void;
+type VariationRecordsCallback = (records: VariationRecord[]) => void;
+export interface WorkflowManager {
+    addPoller: (poller: Poller) => void;
+    addConfirmCallback: (callback: ConfirmCallback) => void;
+    addCurrentVariationCallback: (callback: CurrentVariationRecordCallback) => 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;
+    addVariationRecord: (variationRecord: Omit<VariationRecord, "recordNumber">) => VariationRecord;
+    addVariationRecordsCallback: (callback: VariationRecordsCallback) => void;
+    getCommandDispatcher: () => (command: _CanvasCommand1) => void;
+    getCurrentVariationRecord: () => VariationRecord | undefined;
+    getVariationRecords: () => VariationRecord[];
+    getCommandContext: () => _CommandContext1;
+    getLayouts: () => _ILayout1[];
+    getAllLayoutData: () => LayoutState[];
+    getLayoutPreviewService: () => any | undefined;
+    getPreviewService: () => any | undefined;
+    getProfanities: () => string[];
+    getRegionElements: (stepName: string) => RegionElement[];
+    getSerializedStep: (stepName: string, serializedSteps: SerializableStep[]) => SerializableStep | undefined;
+    getStepSpecificServices: (stepName: string) => StepSpecificServices | undefined;
+    getStepStorage: (stepName: string) => _StepStorage1 | 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: () => _Workflow1;
+    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>;
+    removeVariationRecord: (recordNumber: number) => VariationRecord[];
+    reset: () => Promise<void>;
+    setCurrentAdjustingStepId: (stepId: string) => void;
+    /**
+     * Sets the given variation record. NOTE: This is also used to update existing variation records.
+     */
+    setCurrentVariationRecord: (variationRecord: null | VariationRecord) => void;
+    setEditedStatus: (stepName: string, status: boolean) => void;
+    setInformationResults: (results: InformationResult[]) => void;
+    setMandatoryFulfilled: (stepName: string, status: boolean) => void;
+    setSelectionsAndElements: (stepName: string, variants: _VariantResource1[], elements: RegionElement[], callback?: () => Promise<void>) => Promise<void>;
+    setVariationRecords: (variationRecords: VariationRecord[]) => 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: () => _CommandState1) => Promise<void>;
+    updateStorage: (stepName: string, update: _StepStorage1) => Promise<void>;
+    getModelContainer: () => any | undefined;
+    setModelContainer: (container: any) => 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.
+     */
+    injectIntoPreviewService(previewService: any): Promise<void>;
+    /**
+     * Ejects the model of this product from the preview service.
+     */
+    ejectFromPreviewService(): void;
+}
+interface StepService<T extends _AnyStepData1> {
+    /**
+     * Initialize the given step, or reload from serialized data if present.
+     */
+    init(stepData: _Step1<T>, workflowManager: WorkflowManager, reducerState?: _LayoutsState1): 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?: _CanvasCommand1;
+    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;
+    };
+}
+export interface DesignCreationMessage {
+    baseCost?: number;
+    designProductId?: string;
+    designProductVariantId?: string;
+    event: string;
+    exportedData: ExportedData;
+    externalCartProductId?: string;
+    externalCartProductVariantId?: string;
+    lineItemImageUrl: string;
+    metadata?: {
+        [stepName: string]: string;
+    };
+    optionsCost: number;
+    processExecutionId?: string;
+    selectedVariants?: SelectedVariants;
+    sku?: string;
+    transactionId: string;
+    transactionOwnerId?: string;
+    weight?: number;
+    workflowViewerLink: string;
+    workflowViewerReadOnlyLink: string;
+}
+/**
+ * Represents a transaction.
+ */
+export 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;
+    /**
+     * When true the transaction is a bulk transaction & will allow for modifying
+     * variations based on bulk configuration on the workflow.
+     */
+    bulk?: boolean;
+    /**
+     * 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?: IntegrationProduct;
+    /**
+     * 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 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 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;
+    /**
+     * The amount of variations associated with this transaction.
+     */
+    variationsCount?: number;
+    /**
+     * URL to open the transaction in the workflow viewer.
+     */
+    workflowViewerLink?: string;
+    workflowViewerReadOnlyLink?: string;
+    previewImageLink?: string;
+    bulkSourceUrl?: string;
+    bulkEmailAddress?: string;
+    lastSyncedAt?: string;
+    /**
+     * The users who have access to this transaction.
+     */
+    stakeholders?: Stakeholder[];
+}
+interface IntegrationProduct {
+    id: string;
+    externalProductId?: string;
+    integration?: Integration;
+}
+interface Integration {
+    id: string;
+    enabled: boolean;
+    externalIntegrationId?: string;
+}
+/**
+ * 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;
+    present?: boolean;
+    imageUrl: string;
+    workflowName: string;
+}
+interface Partner {
+    id?: string;
+    name?: string;
+    currencyCode?: string;
+    customerDetailsPromptMarkdown?: string;
+}
+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 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 bulk creations
+     */
+    bulkConfiguration?: BulkConfiguration;
+    /**
+     * Configuration for conversion. Optional.
+     */
+    conversionConfiguration?: ConversionConfiguration;
+    integrationProducts?: IntegrationProduct[];
+    productTags?: ProductTag[];
+}
+interface ProductTag {
+    id: string;
+    name: string;
+}
+export interface ColorOption {
+    id?: string;
+    fill?: string;
+    stroke?: string;
+    variant?: _VariantResource1;
+    colorProfileAssetKey?: string;
+}
+/**
+ * Represents a variation as seen in Google sheets.
+ * Record number = row# - 1
+ */
+export interface VariationRecord {
+    recordNumber: number;
+    transactionId: string;
+    values: {
+        stepName: string;
+        aspect: string;
+        value: string;
+    }[];
+}
+export 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;
+}
+export interface SelectionStorage {
+    selectedVariants?: _VariantResource1[];
+}
+export 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;
+}
+/**
+ * Defines the different behaviors supported by the camera system
+ * for control when viewing a product.
+ */
+export enum ProductCameraRig {
+    Orbit = 0,
+    Pan = 1
+}
+/**
+ * Defines the different strategies to use when calculating the total price
+ * when creating bulk designs.
+ */
+export enum BulkPriceCalculationStrategy {
+    /** The total price should increase with the amount of variations. */
+    PerVariation = "PerVariation",
+    /** The total price should remain at the base price of the product. */
+    BaseProduct = "BaseProduct"
+}
+interface BulkConfiguration {
+    id: string;
+    name?: string;
+    sceneTitle: string;
+    stepTitle: string;
+    helpText?: string;
+    supportsGoogleSheet: boolean;
+    maxVariations: number;
+    pricingStrategy: BulkPriceCalculationStrategy;
+}
+/**
+ * Defines the locations at which a conversion attempt can take place.
+ */
+export 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 quiting 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.
+ */
+export enum ConversionDataType {
+    Email = "Email",
+    FirstName = "FirstName",
+    LastName = "LastName",
+    Phone = "Phone"
+}
+export interface ConversionData {
+    type: ConversionDataType;
+    mandatory: boolean;
+}
+/**
+ * The configuration for conversion, exposed on products currently.
+ */
+export 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.
+ */
+export interface Customer {
+    id?: string;
+    emailAddress: string;
+    firstName?: string;
+    lastName?: string;
+    phoneNumber?: string;
+    loginToken?: string;
+    partner?: Partner;
+    stakeholders?: Stakeholder[];
+    bundleStakeholders?: BundleStakeholder[];
+}
+export interface CustomerDetailsInput {
+    emailAddress: string;
+    firstName?: string;
+    lastName?: string;
+    phoneNumber?: string;
+}
+export enum StakeholderType {
+    Owner = "Owner",
+    Approver = "Approver",
+    Editor = "Editor",
+    Viewer = "Viewer"
+}
+export interface Stakeholder {
+    id: string;
+    type?: StakeholderType;
+    transaction?: Transaction;
+    customer?: Customer;
+}
+interface Bundle {
+    id?: string;
+    bundleOwnerId?: string;
+    bundleStakeholders?: BundleStakeholder[];
+    metadata?: {
+        key: string;
+        value: string;
+    }[];
+    name?: string;
+    partner?: Partner;
+    productCollection?: ProductCollection;
+    transactions?: Transaction[];
+}
+interface BundleStakeholder {
+    id: string;
+    bundle?: Bundle;
+    customer?: Customer;
+    type?: StakeholderType;
+}
+interface BundleStakeholderInput {
+    type: StakeholderType;
+    customerDetails: CustomerDetailsInput;
+}
+type ProductCollection = {
+    id: string;
+    globalPropertyConfiguration?: GlobalPropertyConfiguration;
+    name: string;
+    products: Product[];
+};
+type GlobalPropertyState = {
+    id: string;
+    aspects: GlobalPropertyStateAspect[];
+};
+type GlobalPropertyStateAspect = {
+    name: string;
+    value: string;
+};
+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;
+}
+export const persistenceService: StorageService;
+declare class GraphQlManager {
+    constructor();
+    getShadowGraphqlClient(): ApolloClient<any>;
+}
+export const graphQlManager: GraphQlManager;
+/**
+ * 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<_Asset1>;
+}
+declare class AssetService implements AssetManager {
+    /**
+     * Allows for retrieving an asset, returns the option from a cache if possible.
+     */
+    getLocalOrFromServer(assetKey: string): Promise<_Asset1>;
+    /**
+     * Allows for retrieving amaterial, 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: _AssetType1, onProgress: (val: number) => void, anonymous?: boolean, temporary?: boolean): Promise<_Asset1>;
+    uploadFile(file: File, onProgress: (val: number) => void): Promise<_Asset1>;
+    removePersistedAsset(assetKey: string): void;
+    getPersistedAssets(): PersistedAsset[];
+    /**
+     * Convert a File object for an image into a FileInfo.
+     */
+    loadImageAsFileInfo: (file: File) => Promise<FileInfo>;
+}
+interface PersistedAsset {
+    assetKey: string;
+    src: string;
+}
+export const assetService: AssetService;
+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 | _OptionResource1>;
+    getAssetTileImageForVariant(variant: _VariantResource1): Promise<string>;
+    getDefaultVariant(option: _OptionResource1): _VariantResource1 | undefined;
+    getDisplayImageSource: (variant?: _VariantResource1) => undefined | string;
+    /**
+     * Returns the first variant marked as selected. This is used by most steps.
+     */
+    getSelectedVariant: (option: _OptionResource1 | undefined, selectedVariantIds: string[]) => _VariantResource1 | undefined;
+}
+export const optionService: OptionService;
+export const CommandContextContext: import("react").Context<_CommandContext1>;
+export const useLayouts: () => {
+    commandDispatcher: (command: _CanvasCommand1, leaveOffUndoStack: boolean) => void;
+    getLayoutById: (id: string) => _LayoutData1;
+    getAllLayouts: () => _LayoutData1[];
+    getReducerState: () => _CommandState1;
+    lastUpdated: Date;
+    flattenSequence: (sequenceId: string, initialState: _LayoutsState1) => void;
+};
+export type CommandDispatcher = (command: _CanvasCommand1, leaveOffUndoStack: boolean) => void;
+export type LayoutGetter = (layoutId: string) => _LayoutData1;
+export type LayoutsGetter = () => _LayoutData1[];
+/**
+ * Details about a guideline that can be drawn on the canvas.
+ */
+interface SnapPoint {
+    type: "x" | "y" | "rotation";
+    value: number;
+    svgNode?: ReactNode;
+    anchorPoint: number;
+    guidelineCoordinates?: Point[];
+}
+export enum ElementEventType {
+    Translate = "Translate",
+    Rotate = "Rotate",
+    Resize = "Resize"
+}
+export enum KeyEvent {
+    ControlLeft = "ControlLeft",
+    ControlRight = "ControlRight",
+    Equal = "Equal",
+    MetaLeft = "MetaLeft",
+    MetaRight = "MetaRight",
+    Minus = "Minus",
+    ArrowLeft = "ArrowLeft",
+    ArrowRight = "ArrowRight",
+    ArrowUp = "ArrowUp",
+    ArrowDown = "ArrowDown",
+    AltLeft = "AltLeft",
+    AltRight = "AltRight",
+    Delete = "Delete",
+    Backspace = "Backspace"
+}
+type ElementEvent = {
+    type: ElementEventType.Translate;
+} | {
+    type: ElementEventType.Rotate;
+} | {
+    type: ElementEventType.Resize;
+    relativeAxis: ScaleAxis;
+    screenAxis: ScaleAxis;
+};
+export enum EditorSubMenu {
+    None = "None",
+    FrameAdjustment = "FrameAdjustment",
+    Variations = "Variations",
+    FinalizeDesign = "FinalizeDesign",
+    SavedDesigns = "SavedDesigns",
+    ThreeDPreview = "ThreeDPreview",
+    Panels = "Panels"
+}
+interface UIState {
+}
+/**
+ * This context stores global state for
+ */
+export interface AdvancedEditorState extends UIState {
+    /**
+     * The layout currently being displayed in the editor.
+     */
+    layoutId: string;
+    /**
+     * Returns the id of the currently selected element. Or undefined if no element is selected.
+     */
+    selectedElement?: string;
+    /**
+     * The current zoom level of the editor.
+     */
+    zoom: number;
+    /**
+     * The current x translation of the transform for the canvas.
+     */
+    xTranslation: number;
+    /**
+     * The current y translation of the transform for the canvas.
+     */
+    yTranslation: number;
+    /**
+     * The maxiumum zoom possible based on current canvas content.
+     */
+    maxZoom: number;
+    /**
+     * The current measurement system used for display of coordinates and dimensions.
+     */
+    units: _UnitOfMeasurement1;
+    /**
+     * The sub menu to be displayed to the user in place of the canvas.
+     */
+    subMenu: EditorSubMenu;
+    /**
+     * Any modifier keys that are currently pressed
+     */
+    activeModifierKeys: KeyEvent[];
+    /**
+     * WHether or not a meta key is pressed.
+     */
+    metaPressed: boolean;
+    /**
+     * Any active element event.
+     */
+    elementEvent?: ElementEvent;
+    /**
+     * If movement should assume that it's operating in a scrolled environment.
+     * FIXME: Can we get rid of this somehow.
+     */
+    scrolledMovement: boolean;
+}
+export const getDefaultState: (getLayouts: LayoutsGetter, defaultZoom: number) => AdvancedEditorState;
+export const commandReducer: (state: AdvancedEditorState, command: UICommand) => AdvancedEditorState;
+export const AdvancedEditorContext: import("react").Context<{
+    uiDispatcher: Dispatch<UICommand>;
+    state: AdvancedEditorState;
+}>;
+export const AdvancedEditorStateProvider: FunctionComponent<{
+    defaultZoom?: number;
+    children: ReactNode;
+}>;
+export class UICommand {
+    constructor(changes: Partial<AdvancedEditorState>);
+    apply(state: AdvancedEditorState): {
+        layoutId: string;
+        selectedElement?: string | undefined;
+        zoom: number;
+        xTranslation: number;
+        yTranslation: number;
+        maxZoom: number;
+        units: _UnitOfMeasurement1;
+        subMenu: EditorSubMenu;
+        activeModifierKeys: KeyEvent[];
+        metaPressed: boolean;
+        elementEvent?: ElementEvent | undefined;
+        scrolledMovement: boolean;
+    };
+}
+export const useEditorState: () => {
+    uiDispatcher: Dispatch<UICommand>;
+    state: AdvancedEditorState;
+};
+/**
+ * The minimum zoom that can be applied to a canvas.
+ */
+export const minZoom = 0.5;
+export const useEditorInteraction: (editorRef: RefObject<SVGRectElement>, interactionRef: RefObject<HTMLDivElement>, zoomableElementRef: RefObject<HTMLDivElement>, defaultAdjustmentZoom: number | undefined, mode: "adjustment" | "advanced", canvasDispatcher: CommandDispatcher, breakpoint: string, guidelinePrimaryColor?: string, onSequenceComplete?: () => void) => {
+    guidelines: SnapPoint[];
+    scale: number;
+    zoomableElementRef: RefObject<HTMLDivElement>;
+    setElementEvent: (newEvent: ElementEvent | undefined) => void;
+    handleZoom: (_event: any, value: any) => void;
+    handleKeyDown: (event: KeyboardEvent, adjustmentBoundary?: Region) => void;
+    handleKeyUp: (event: KeyboardEvent) => void;
+    handlePointerPressedBackground: (event: PointerEvent) => void;
+    handlePointerReleased: () => void;
+    handlePointerMove: (event: PointerEvent, adjustmentBoundary?: Region) => void;
+    handleScroll: () => void;
+    handleSequenceStart: () => void;
+};
+export const useShortcutCombination: (shortcutKeys: string[], onCombinationPressed: () => void, onCombinationReleased?: () => void) => void;
+export interface DesignInputStep {
+    data: DesignInputStepData;
+    name: string;
+}
+interface DesignInputStepData {
+}
+export const generateCommands: (designInputSteps: DesignInputStep[], workflow: _Workflow1, layouts: _ILayout1[], productOverlayImageUrl?: string) => Promise<_CanvasCommand1[]>;
+export const EditorCore: FunctionComponent<{
+    isMobile: boolean;
+    color?: string;
+    outlineColor?: string;
+    editorRef: RefObject<SVGRectElement>;
+    zoomableElementRef: RefObject<HTMLDivElement>;
+    interactionElementRef: RefObject<HTMLDivElement>;
+    guidelines: SnapPoint[];
+    isMakingAdjustments?: boolean;
+    outlineArea?: {
+        x?: number;
+        y?: number;
+        height?: number;
+        width?: number;
+        hidden?: boolean;
+    };
+    visibleLayoutId: string;
+    xTranslation: number;
+    yTranslation: number;
+    targetedElements?: string[];
+    borderRadius?: number;
+    canvasFilter?: string;
+    handleContextMenu?: (e: any) => void;
+    onMouseMove?: (event: React.MouseEvent<SVGRectElement, MouseEvent>) => void;
+    onContextMenuHandlePointerDown?: (event: PointerEvent) => void;
+    handleKeyDown: (event: KeyboardEvent, adjustmentBoundary?: Region) => void;
+    handleKeyUp: (event: KeyboardEvent) => void;
+    handlePointerMove: (e: PointerEvent, adjustmentBoundary?: Region) => void;
+    handlePointerPressedBackground: (event: PointerEvent) => void;
+    handlePointerReleased: () => void;
+    handleScroll: () => void;
+    onSequenceStart: () => void;
+    setElementEvent: (e: ElementEvent | undefined) => void;
+    onElementSelected: (elementId: string | undefined, event: PointerEvent) => void;
+    variationRecord: null | VariationRecord;
+    workflow: _Workflow1;
+}>;
+/**
+ * The advanced editor encapsulates the logic required to allow users to manipulate a design
+ * with more granular control such as toolbars, direct element manipulation, and more.
+ */
+export const AdvancedEditor: FunctionComponent<{
+    borderRadius?: number;
+    canvasFilter?: string;
+    color?: string;
+    guidelineColor?: string;
+    handleContextMenu?: (event: React.MouseEvent) => void;
+    hideEditableAreaRect?: boolean;
+    isMobile: boolean;
+    onContextMenuHandlePointerDown?: (event: PointerEvent) => void;
+    onDragEnd?: () => void;
+    onElementSelected?: (id: string | undefined, element: PointerEvent) => void;
+    onMouseMove?: (event: React.MouseEvent<SVGRectElement, MouseEvent>) => void;
+    outlineColor?: string;
+    variationRecord: null | VariationRecord;
+    workflow: _Workflow1;
+}>;
+/**
+ * A wrapping component that provides a simple interface for interacting with a variant.
+ */
+export class Variant {
+    constructor(variant: _VariantResource1);
+    getType(): _AssetType1 | 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 a thumbnail resource configured on this variant. When no thumbnail is configured explicitly we fall back to the base asset and see if a thumbnail is genererated for that.
+     */
+    getThumbnail(): string | undefined;
+    /**
+     * @returns The URL for the display image configured on this variant. Can be used for things like size charts.
+     */
+    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(): _VariantResource1;
+    /**
+     * @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.
+ */
+export abstract class StepHandle<T extends _AnyStepData1> {
+    /**
+     * 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: _Step1<T>;
+    constructor(manager: WorkflowManager, step: _Step1<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(): _StepType1;
+    /**
+     * @returns The underlying data for this step. Favor using the step handle methods instead of this.
+     */
+    getRaw(): _Step1<T>;
+    /**
+     * 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;
+}
+export class BulkStepHandle extends StepHandle<_BulkStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_BulkStepData1>);
+    selectVariant(): Promise<void>;
+    setDesignName(designName: string): Promise<void>;
+    addVariationRecord(): VariationRecord;
+    updateBulkIsConnected(bulkIsConnected: boolean): void;
+    /**
+     * Opens the bulk source in a seperate tab. This bulk source could be a google sheet or a csv file.
+     */
+    openBulkSourceUrl(): void;
+    sendGoogleSheetLinkToEmail(email: string): Promise<void>;
+    /**
+     * Removes a variation from the bulk step.
+     * @param recordNumber The record number of the variation to remove.
+     */
+    deleteVariationRecord(recordNumber: number): void;
+    /**
+     * @returns The aspects of each step that are modifiable from the bulk handle. These are configured in the workflow.
+     */
+    getAspects(): import("@spiffcommerce/papyrus").StepAspect[];
+}
+export class IllustrationStepHandle extends StepHandle<_IllustrationStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_IllustrationStepData1>);
+    /**
+     * 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]: import("@spiffcommerce/papyrus").ColorDefinition;
+    } | undefined;
+    /**
+     * Set color for the illustration.
+     */
+    setColor(key: string, value: string): Promise<void>;
+    getColorOption(): Promise<import("@spiffcommerce/papyrus").OptionResource | undefined>;
+    getAvailableColors(): Promise<{
+        fill: string | undefined;
+        stroke: string | undefined;
+        variant: import("@spiffcommerce/papyrus").VariantResource;
+    }[] | undefined>;
+    hasVaryingSelection(): boolean | undefined;
+    hasVaryingColors(): boolean | undefined;
+    isColorPickerEnabled(): boolean | undefined;
+}
+export class MaterialStepHandle extends StepHandle<_MaterialStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_MaterialStepData1>);
+    selectVariant(variant: Variant): Promise<void>;
+}
+export class ModelStepHandle extends StepHandle<_ModelStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_ModelStepData1>);
+    selectVariant(variant: Variant): Promise<void>;
+}
+export class PictureStepHandle extends StepHandle<_PictureStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_PictureStepData1>);
+    /**
+     * 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>;
+}
+export class QuestionStepHandle extends StepHandle<_QuestionStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_QuestionStepData1>);
+    selectVariant(variant: Variant): Promise<void>;
+    /**
+     * The way that this step expects to be rendered.
+     */
+    getDisplayType(): string | undefined;
+}
+export class ShapeStepHandle extends StepHandle<_ShapeStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_ShapeStepData1>);
+    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: import("@spiffcommerce/papyrus").VariantResource;
+    }[]>;
+}
+interface TextChangeResult {
+    input: string;
+    helperText?: string;
+    errorText?: string;
+}
+export class TextStepHandle extends StepHandle<_TextStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_TextStepData1>);
+    /**
+     * 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;
+    /**
+     * 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;
+    hasVaryingText(): boolean | undefined;
+    hasVaryingColor(): boolean | undefined;
+    hasVaryingSelection(): boolean | undefined;
+    hasColorPicker(): boolean | undefined;
+    getRegions(): import("@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;
+}
+export const createDesign: (workflowManager: WorkflowManager, workflow: _Workflow1, layouts: _ILayout1[], getReducerState: () => _CommandState1, product: Product, transaction: Transaction, workflowSelections: WorkflowSelections, designName: string, onProgressUpdate: DesignCreationProgressUpdate, updateVariationRecords: (variationRecords: VariationRecord[]) => Promise<void>, variationRecords: VariationRecord[], createPreviewImage: (shouldRender3D?: boolean) => Promise<string>, workflowMetadata?: WorkflowMetadata) => Promise<DesignCreationMessage>;
+export 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";
+    /**
+     * @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>;
+}
+export 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[];
+}
+/**
+ * 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.
+ */
+export interface WorkflowExperience {
+    /**
+     * 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;
+    /**
+     * Bulk workflow operation, used to update multiple variations at once.
+     */
+    updateVariationRecords(variationRecords: VariationRecord[]): Promise<void>;
+    /**
+     * Returns the step matching a given name, undefined if not found.
+     * @param id The id the step must match.
+     */
+    getStepById(id: string): StepHandle<_AnyStepData1> | undefined;
+    /**
+     * Returns the bulk step, undefined if not found.
+     */
+    getBulkStep(): BulkStepHandle | undefined;
+    /**
+     * Returns the step matching a given name, undefined if not found.
+     * @param name The name the step must match.
+     */
+    getStepByName(name: string): StepHandle<_AnyStepData1> | 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: _StepType1): StepHandle<_AnyStepData1>[];
+    /**
+     * Returns all steps that are children of a given scene.
+     * @param scene The scene you want the steps for.
+     */
+    getStepsByScene(scene: Scene): StepHandle<_AnyStepData1>[];
+    /**
+     * Returns all steps in the workflow that are currently active. Ordered by scene and appearance within their respective scenes.
+     */
+    getSteps(): StepHandle<_AnyStepData1>[];
+    /**
+     * 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.
+     */
+    getSelectionPriceSubunits(): number;
+    /**
+     * Returns the total cost in subunits for the base product.
+     */
+    getBasePriceSubunits(): number;
+    /**
+     * A convenience function returning the sum of the selection and base price values.
+     */
+    getTotalPriceSubunits(): number;
+    /**
+     * 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
+     */
+    onDesignFinished(onProgressUpdate?: DesignCreationProgressUpdate): 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;
+    }>;
+}
+export enum FrameStep {
+    SelectFrame = "SelectFrame",
+    SelectImage = "SelectImage",
+    Position = "Position"
+}
+export class FrameStepHandle extends StepHandle<_FrameStepData1> {
+    constructor(manager: WorkflowManager, step: _Step1<_FrameStepData1>);
+    selectVariant(variant: Variant): Promise<void>;
+    onFrameDataChanged(callback: (frameData: _FrameData1[]) => void): void;
+    selectImage(asset: _Asset1): void;
+    getImageData(): PatternImageData | undefined;
+    getCurrentFrameStep(frameData: _FrameData1, uploading?: any, imageUploadComplete?: any, variants?: _VariantResource1[]): FrameStep;
+    getFrameService(): FrameService | undefined;
+    hasOverlayImageKey(): string | undefined;
+    hasOverlayImageUrl(): any;
+    hasVaryingUpload(): boolean | undefined;
+    hasVaryingSelection(): boolean | undefined;
+}
+/**
+ * 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: _Bundle1;
+    protected readonly property: GlobalPropertyConfigurationAspect;
+    constructor(bundle: _Bundle1, 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[]): import("stepHandles").StepHandle<import("index").AnyStepData>[];
+}
+interface GlobalPropertyStateManager {
+    getGlobalPropertyState(): GlobalPropertyState | undefined;
+    getAspect(name: string): string | undefined;
+    setAspect(name: string, value: string): Promise<void>;
+}
+/**
+ * A bundle serves as a container for a set of workflow experience.
+ */
+interface _Bundle1 {
+    /**
+     * @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 when the bundle contains products that share global properties.
+     */
+    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>;
+    /**
+     * Remove a workflow experience from this bundle.
+     * @param experience The workflow experience to remove from this bundle.
+     */
+    removeWorkflowExperience(experience: WorkflowExperience): 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>;
+    /**
+     * 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.
+     */
+    finish(): Promise<DesignCreationMessage[]>;
+    /**
+     * 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: BundleEvent, listener: () => void): void;
+    /**
+     * Remove a previously added event listener from this bundle.
+     */
+    removeEventListener(event: BundleEvent, listener: () => void): void;
+}
+type BundleEvent = "conditional-global-properties-changed";
+interface ExecutionResponse {
+    id: string;
+    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 {
+    execute(id: string, inputs: FlowExecutionInput[], options?: {
+        sleepTime: number;
+    }): Promise<ExecutionResponse>;
+}
+/**
+ * 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.
+ */
+export const enum ObjectInputType {
+    Transaction = "Transaction",
+    Bundle = "Bundle",
+    Product = "Product",
+    Variant = "Variant",
+    Option = "Option",
+    LineItem = "LineItem",
+    Asset = "Asset"
+}
+/**
+ * Handles validation of spiffObject structure for transmission to the server.
+ */
+export class ObjectInput extends FlowExecutionInput {
+    constructor(id: string, type: ObjectInputType);
+    static validUUID(uuid: string): RegExpMatchArray | null;
+}
+/**
+ * Handles validation of text input for transmission to the server.
+ */
+export class TextInput extends FlowExecutionInput {
+    constructor(id: string);
+}
+export const getWorkflow: (id: string) => Promise<_Workflow1>;
+/**
+ * Options that can be used during instantiation of the SpiffCommerce Javascript Client.
+ * Please refer to the documentation for more information.
+ */
+interface ClientOptions {
+    /**
+     * When set to true, the client will treat the workflow as a bulk order
+     * containing multiple variations of the base design.
+     * @deprecated Specify when calling getWorkflowExperience instead.
+     */
+    bulk?: boolean;
+    /**
+     * When provided, the client will use the provided application key to
+     * authenticate with the SpiffCommerce API.
+     */
+    applicationKey?: string;
+}
+interface GetWorkflowOptionsBase {
+    /**
+     * An existing preview service to use, instead of creating a new one.
+     */
+    previewService?: any;
+}
+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 GetWorkflowFromIntegrationProductOptions extends GetWorkflowOptionsBase {
+    /** The workflow to load. */
+    workflowId: string;
+    integrationProductId: string;
+    /** An existing workflow state, if available. */
+    workflowState?: string;
+    bulk?: boolean;
+    type: "integration";
+}
+interface GetWorkflowFromExternalProductOptions extends GetWorkflowOptionsBase {
+    /** The workflow to load. */
+    workflowId: string;
+    /** The external ID associated with an integration. */
+    externalIntegrationId: string;
+    /** The ID of the product from the external system. */
+    externalProductId: string;
+    /** An existing workflow state, if available. */
+    workflowState?: string;
+    bulk?: boolean;
+    type: "external";
+}
+export type GetWorkflowOptions = GetWorkflowFromTransactionOptions | GetWorkflowFromIntegrationProductOptions | GetWorkflowFromExternalProductOptions;
+/**
+ * The Spiff Commerce Javascript Client. Required for
+ * creating workflow experiences.
+ */
+export class SpiffCommerceClient {
+    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;
+    /**
+     * 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?: _Theme1;
+    }>;
+    clearCustomer(): void;
+    clearCustomerForTransaction(transactionId: string): void;
+    getStakeholderTypeForTransaction(transactionId: string): StakeholderType | undefined;
+    getOrCreateCustomer(emailAddress: string): Promise<{
+        customer: Customer;
+        isAuthenticated: boolean;
+    }>;
+    /**
+     * 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): Promise<_Bundle1>;
+    /**
+     * Retrieves an existing bundle from the API, by id.
+     * @returns A bundle to be used for grouping and operating on large amounts of workflow experiences.
+     */
+    getExistingBundle(bundleId: string, previewServiceConstructor?: (workflow: _Workflow1, transactionId: string) => any): Promise<_Bundle1>;
+    /**
+     * 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: _Workflow1) => any, options?: GetWorkflowOptions): 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 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(): any;
+    /**
+     * @deprecated The value this returns will be changed whenever `getWorkflowExperience()` is called. Use `WorkflowManager.getProduct()` instead.
+     * @returns The product associated with this client.
+     */
+    getProduct(): import("types").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;
+}
+export class MockWorkflowManager implements WorkflowManager {
+    getInitializationPromise(): Promise<void>;
+    getProduct: () => Product;
+    isInitialized(): boolean;
+    getCommandContext: () => _CommandContext1;
+    getAllLayoutData: () => LayoutState[];
+    getMetadata: (stepName: string) => StepMetadata | undefined;
+    getWorkflowMetadata: () => WorkflowMetadata;
+    getStepStorage: (stepName: string) => _StepStorage1 | undefined;
+    getInformationResults(): InformationResult[];
+    getVariationRecords(): VariationRecord[];
+    reset(): Promise<void>;
+    updateStateWithServer(_getReducerState: () => _CommandState1): void;
+    addVariationRecord(_variationRecord: Omit<VariationRecord, "recordNumber">): {
+        recordNumber: number;
+        transactionId: string;
+        values: never[];
+    };
+    getCurrentVariationRecord(): undefined;
+    removeVariationRecord(_recordNumber: number): never[];
+    outstandingRequestsPromise(): Promise<void>;
+    updateStateWithServerImmediate(_getReducerState: () => _CommandState1): Promise<void>;
+    addPoller(_poller: Poller): void;
+    addConfirmCallback(_callback: ConfirmCallback): void;
+    addCurrentVariationCallback(_callback: CurrentVariationRecordCallback): 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;
+    addVariationRecordsCallback(_callback: VariationRecordsCallback): void;
+    getCommandDispatcher(): (_command: _CanvasCommand1) => void;
+    getLayouts(): never[];
+    getLayoutPreviewService(): {
+        getAll: () => Map<any, 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;
+    setCurrentVariationRecord(_variationRecord: VariationRecord | null): void;
+    setEditedStatus(_stepName: string, _status: boolean): void;
+    setInformationResults(_results: InformationResult[]): void;
+    setMandatoryFulfilled(_stepName: string, _status: boolean): void;
+    setSelectionsAndElements(_stepName: string, _variants: _VariantResource1[], _elements: RegionElement[]): Promise<void>;
+    setVariationRecords(_variationRecords: VariationRecord[]): void;
+    toggleDesignConfirmed(): void;
+    updateMetadata(_stepName: string, _update: any): void;
+    updateStorage(_stepName: string, _update: _StepStorage1): Promise<void>;
+    injectIntoPreviewService(_previewService: any): Promise<void>;
+    ejectFromPreviewService(): void;
+}
+export const TransformWrapper: React.FunctionComponent;
+export { CommandContext };
+export { AssetType, BringForwardCommand, BringToFrontCommand, BringToBackCommand, CanvasCommand, CreateElementCommand, CreateLayoutCommand, DeleteElementCommand, FontAlignmentCommand, FontColorCommand, FontSizeCommand, FontSourceCommand, GroupCommand, LayoutElementFactory, LayoutElementType, MoveCommand, ResizeCommand, RotateCommand, SendBackwardsCommand, StepAspectType, StepType, TextChangeCommand, UnitOfMeasurement, dataUrlFromExternalUrl, findElement, frameDataCache, generate, getAxisAlignedBoundingBox, generateSVGWithUnknownColors, getAttributesFromArrayBuffer, rehydrateSerializedLayout, getFrameData, getSvgElement, loadFontFromDataUrl, loadFontFromExternalUrl, determineCorrectFontSizeAndLines, patternImageDataCache, registerJSDOM };
+export { Animatable, AnyStepData, Asset, BulkStepData, ColorProfileProps, ColorDefinition, CommandState, WorkflowPanel, DigitalContentStepData, FrameElement, FrameStepData, ILayout, IllustrationElement, IllustrationStepData, ImageElement, LayoutData, LayoutElement, LayoutsState, MaterialStepData, ModelStepData, ModuleStepData, OptionResource, PictureStepData, QuestionStepData, ShapeStepData, Step, StepAspect, StepStorage, TextStepData, TextboxElement, Theme, VariantResource, Workflow };
+
+//# sourceMappingURL=types.d.ts.map