@spiffcommerce/core 0.2.0

package/dist/types.d.ts

@@ -0,0 +1,1163 @@
+import { AnyStepData, Step, Asset, AssetType, IServerModel, MaterialResource, VariantResource, Workflow, CameraAnimation, ModelAnimation, OptionResource, StepType, TextStepData } from "papyrus/build/main/generation/Workflow";
+import { PatternImageData, ScaleAxis, UnitOfMeasurement } from "papyrus/build/main/types";
+import { FrameOffsets, ILayout, SerializableStep, StepStorage, Region, LayoutsState as _LayoutsState1, LayoutElement, LayoutsState, TextboxElement, ImageElement } from "papyrus/build/main/LayoutsState/types";
+import { ModuleProduct } from "papyrus/build/main/module/ModuleProduct";
+import { CanvasCommand, CreateElementCommand, FontAlignmentCommand, FontColorCommand, TextChangeCommand } from "papyrus/build/main/command";
+import { CommandState, CommandContext as _CommandContext1, LayoutData as _LayoutData1, CommandContext, LayoutData } from "papyrus/build/main/CommandContext";
+import { Dispatch, FunctionComponent, ReactNode, MouseEvent, PointerEvent } from "react";
+import { ThreeDPreviewService as _ThreeDPreviewService1, SpiffCommerce3DPreviewService } from "spiff-preview";
+import { LayoutElementFactory } from "papyrus/build/main/Elements/factory";
+interface WorkflowScene {
+    name: string;
+    title: string;
+    renderableSteps: Step<AnyStepData>[];
+    silentSteps: Step<AnyStepData>[];
+}
+interface WorkflowScenesConfiguration {
+    bulkScene: boolean;
+    bulkSceneTitle: string;
+    finishScene: boolean;
+    finishSceneTitle: string;
+}
+declare class FrameService {
+    minZoomScale: number;
+    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
+     * @param path The path to lookup in our frame data cache.
+     */
+    setFrameData(path: string): Promise<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.
+     * @param cX The center of zoom on x axis
+     * @param cY The center of zoom on Y axis
+     * @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 object.
+     * @param onComplete A callback, called when the modification is complete
+     */
+    updateOffsets(value: FrameOffsets, onComplete?: () => void): 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 SwaggerServer implements ServerService {
+    constructor();
+    setUncachedOperations(operationIds: string[]): void;
+    execute(operationName: string, parameters?: object): Promise<ServerResponse>;
+}
+export const server: SwaggerServer;
+declare class AssetService {
+    constructor();
+    /**
+     * Allows for retrieving an asset, returns the option from a cache if possible.
+     * @param server The server service for making the request.
+     * @param id The asset key to be retrieved.
+     */
+    getLocalOrFromServer(assetKey: string): Promise<IServerModel<Asset>>;
+    /**
+     * Allows for retrieving amaterial, returns the option from a cache if possible.
+     * @param server The server service for making the request.
+     * @param id The option ID to be retrieved.
+     */
+    getMaterialLocalOrFromServer(id: string): Promise<IServerModel<MaterialResource>>;
+    /**
+     * Upload a user asset to the server. Using callbacks to notify important events.
+     */
+    uploadAssetWithProgress(file: FileInfo, assetType: AssetType, onProgress: (val: number) => void, onComplete: (asset: IServerModel<Asset>) => void, anonymous?: boolean, partnerId?: string): Promise<IServerModel<Asset>>;
+    /**
+     * Convert a File object for an image into a FileInfo.
+     */
+    loadImageAsFileInfo: (file: File) => Promise<FileInfo>;
+}
+export const assetService: AssetService;
+interface EditedSteps {
+    [stepName: string]: boolean;
+}
+interface MandatorySteps {
+    [stepName: string]: boolean;
+}
+type StepElements = {
+    [key: string]: RegionElement[];
+};
+type StepInitialised = {
+    [key: string]: boolean;
+};
+type StepMetadata = FrameMetadata | IllustrationMetadata | ModuleMetadata | TextMetadata;
+interface WorkflowStorage {
+    [stepName: string]: StepStorage;
+}
+interface WorkflowMetadata {
+    [stepName: string]: StepMetadata;
+}
+interface WorkflowSelections {
+    [stepName: string]: {
+        groupName?: string;
+        optionName: string;
+        selections: VariantResource[];
+    };
+}
+interface InformationResult {
+    message: string;
+    messageType: InformationMessageType;
+    stepID: string;
+}
+enum InformationMessageType {
+    Error = "Error",
+    Warning = "Warning"
+}
+/**
+ * Services required for the operaiton of individual steps.
+ */
+interface StepSpecificServices {
+    frameService?: FrameService;
+    module?: ModuleProduct;
+}
+type DesignCreationProgressUpdate = (message: string) => void;
+type ConfirmCallback = (isConfirmed: boolean) => void;
+type EditedCallback = (editedSteps: EditedSteps) => void;
+type ElementsCallback = (elements: StepElements) => void;
+type InformationResultCallback = (messages: InformationResult[]) => void;
+type InitCallback = (stepInitialised: StepInitialised) => void;
+type MakingAdjustmentsCallback = (makingAdjustments: string) => void;
+type MandatoryCallback = (mandatorySteps: MandatorySteps) => void;
+type MetadataCallback = (metadata: WorkflowMetadata) => void;
+type SelectionCallback = (callbackOptions: {
+    invalidModelVariants: string[];
+    selectionCost: number;
+    selections: StepSelections;
+    traversableScenes: WorkflowScene[];
+}) => void;
+type StepSpecificStorageCallback = (selections: StepStorage) => void;
+type StorageCallback = (storage: WorkflowStorage) => void;
+type UpdateCallback = (isUpdating: boolean) => void;
+type CurrentVariationRecordCallback = (variationRecord: null | VariationRecord) => void;
+type VariationRecordsCallback = (records: VariationRecord[]) => void;
+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;
+    addUpdateCallback: (callback: UpdateCallback) => void;
+    addVariationRecord: (variationRecord: Omit<VariationRecord, "recordNumber">) => VariationRecord;
+    addVariationRecordsCallback: (callback: VariationRecordsCallback) => void;
+    getCommandDispatcher: () => (command: CanvasCommand) => void;
+    getCurrentVariationRecord: () => VariationRecord | undefined;
+    getVariationRecords: () => VariationRecord[];
+    getLayouts: () => ILayout[];
+    getLayoutPreviewService: () => any;
+    getPreviewService: () => ThreeDPreviewService | undefined;
+    getProductName: () => string | undefined;
+    getProfanities: () => string[];
+    getRegionElements: (stepName: string) => RegionElement[];
+    getSerializedStep: (stepName: string, serializedSteps: SerializableStep[]) => SerializableStep | undefined;
+    getStepSpecificServices: (stepName: string) => StepSpecificServices | undefined;
+    getTransaction: () => Transaction;
+    getWorkflow: () => Workflow;
+    getWorkflowSelections: () => WorkflowSelections;
+    markStepsAsInitialised: (stepNames: string[]) => void;
+    markUpdateCompleted: (update: string) => void;
+    markUpdatePending: (update: string) => void;
+    outstandingRequestsPromise: () => Promise<void>;
+    removeVariationRecord: (recordNumber: number) => VariationRecord[];
+    reset: () => Promise<void>;
+    setCurrentAdjustingStepId: (stepId: string) => void;
+    setAllScenes: (config: WorkflowScenesConfiguration) => void;
+    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: VariantResource[], elements: RegionElement[]) => Promise<void>;
+    setVariationRecords: (variationRecords: VariationRecord[]) => void;
+    toggleDesignConfirmed: () => void;
+    updateMetadata: (stepName: string, update: any) => void;
+    updateStateWithServer: (getReducerState: () => CommandState) => void;
+    updateStateWithServerImmediate: (getReducerState: () => CommandState) => Promise<void>;
+    updateStorage: (stepName: string, update: StepStorage) => Promise<void>;
+}
+interface FileInfo {
+    /**
+     * The name of the file.
+     */
+    name: string;
+    /**
+     * A blob object representing the
+     * data of the file.
+     */
+    blob: Blob;
+}
+/**
+ * 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;
+    weight?: number;
+    designProductId?: string;
+    designProductVariantId?: string;
+    event: string;
+    exportedData: ExportedData;
+    lineItemImageUrl: string;
+    transactionId: string;
+    metadata?: {
+        [stepName: string]: string;
+    };
+    optionsCost: number;
+    selectedVariants?: SelectedVariants;
+    sku?: string;
+    workflowViewerLink: string;
+}
+/**
+ * Represents a transaction.
+ */
+interface Transaction {
+    id: string;
+    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 line item corresponding to this transaction.
+     */
+    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.
+     */
+    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.
+     */
+    externalDesignProductId?: string;
+    priceModifierTotal?: number;
+    /**
+     * The amount of variations associated with this transaction.
+     */
+    variationsCount?: number;
+    /**
+     * URL to open the transaction in the workflow viewer.
+     */
+    workflowViewerLink?: string;
+    bulkSourceUrl?: 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 Product {
+    /**
+     * ID of the partner owner.
+     */
+    partnerId?: string;
+    /**
+     * 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;
+}
+/**
+ * Represents a variation as seen in Google sheets.
+ * Record number = row# - 1
+ */
+interface VariationRecord {
+    recordNumber: number;
+    transactionId: string;
+    values: {
+        stepName: string;
+        aspect: string;
+        value: string;
+    }[];
+}
+interface RegionElement {
+    id: string;
+    region?: Region;
+}
+interface FrameMetadata {
+    image: string;
+}
+interface IllustrationMetadata {
+    colors: string[];
+}
+interface ModuleMetadata {
+    text: string;
+}
+interface TextMetadata {
+    color?: string;
+    text: string;
+}
+interface SelectionStorage {
+    selectedVariants?: VariantResource[];
+}
+type StepSelections = {
+    [key: string]: SelectionStorage;
+};
+interface ServerResponse {
+    /**
+     * Will contain error information if an error was recieved
+     */
+    errors?: string[];
+    /**
+     * The body of the response containing any return data.
+     */
+    body: object;
+    headers: {
+        "content-type": string;
+    };
+}
+interface ServerService {
+    /**
+     * Sets the operation names that should be converted to their correspondingun-cached equivelants.
+     */
+    setUncachedOperations: (operationIds: string[]) => void;
+    /**
+     * Execute an operation against the server.
+     */
+    execute: (operationId: string, operationParameters?: object, anonymous?: boolean) => Promise<ServerResponse>;
+}
+interface FrameData {
+    /**
+     * The path data for a frame SVG
+     */
+    path: string;
+    /**
+     *  The viewbox width
+     */
+    width: number;
+    /**
+     * The viewbox height.
+     */
+    height: number;
+}
+type ThreeDPreviewService = {
+    /**
+     * Allows listeners to be aware of the camera losing focus of the
+     * main product.
+     * @param listener A function to be called when focus is lost.
+     */
+    registerFocusLostListener(listener: () => void): void;
+    /**
+     * Removes a listener from the focusLost observers. The listener will
+     * no longer be notified
+     * @param listener The listener to remove.
+     */
+    unregisterFocusLostListener(listener: () => void): void;
+    /**
+     * Providers listeners with information about load progress when
+     * the preview is loading scenes.
+     * @param listener A function to get load progress updates
+     */
+    registerLoadProgressListener(listener: (e: LoadProgressEventData) => void): void;
+    /**
+     * Allows you to pass any function that originally called registerLoadProgressListener()
+     * to have it excluded from load progress updates.
+     * If the function was never registered this call has no effect.
+     * @param listener The listener to exclude from load progress.
+     */
+    unregisterLoadProgressListener(listener: (e: LoadProgressEventData) => void): void;
+    /**
+     * Request that the scene renders to a given canvas
+     * @param canvas The canvas we should render to.
+     */
+    registerView(canvas: HTMLCanvasElement): void;
+    /**
+     * Returns the number of active viewers of the scene. Useful for
+     * avoiding unnecessary rendering when there are no active viewers.
+     */
+    getNumViewports(): number;
+    /**
+     * Tells babylon that we no longer want the given canvas to be rendered to.
+     * @param canvas The canvas to be excluded from rendering.
+     */
+    unregisterView(canvas: HTMLCanvasElement): void;
+    /**
+     * Shutdown the preview engine. Noop if the engine is not initialized.
+     */
+    shutdown(): void;
+    /**
+     * Initialize the scene. Also initialize the engine, if it hasn't been done already.
+     */
+    initialize(src: string, contextService?: RenderableContextService): Promise<void>;
+    /**
+     * Executes an animation in the currently loaded scene.
+     * @param animation The current animation track to run.
+     */
+    executeModelAnimation(animation: ModelAnimation): void;
+    /**
+     * Executes an animation of the camera.
+     * @param animation The animation to execute.
+     */
+    executeCameraAnimation(animation: CameraAnimation): void;
+    /**
+     * Returns the values of the Arc Rotate Camera
+     */
+    getCameraPose(): CameraPose | undefined;
+    /**
+     * Sets the values of the Arc Rotate Camera
+     */
+    setCameraPose(cameraPose: CameraPose): void;
+    /**
+     * Applies a given material modifier to a target material in the scene.
+     * @param targetMaterial The material to target.
+     * @param key A unique key used to identify this action.
+     * @param material The material modifier to apply.
+     */
+    applyMaterialVariant(targetMaterial: string, key: string, material: MaterialResource, removeWhenUndefined?: boolean): Promise<void>;
+    /**
+     * Applies a given model variant to the scene.
+     * @param key A unique key used to identify this action.
+     * @param modelDetails An asset containing a model file to be loaded into the scene.
+     */
+    applyModelVariant(key: string, modelDetails: ModelDetails, replaceProductModel: boolean): Promise<void>;
+    /**
+     * Controls the current control state of the camera.
+     * @param rigType The control type to use.
+     */
+    setCameraState(rigType: ProductCameraRig): void;
+    /**
+     * Restores the product camera to it's last set focus point. If the user has
+     * been panning this will animate the camera to the original focus point. If the camera is still
+     * focused on it's origin point this function is a noop.
+     */
+    animateToLastCameraFocus(): Promise<void>;
+    /**
+     * When configuration has allowed for auto rotation we
+     * can pause the rotation via this function.
+     * @param shouldAutoRotate When true rotation is running, paused otherwise.
+     */
+    setAutoRotation(shouldAutoRotate: boolean): void;
+    /**
+     * Get current load progress for the scene.
+     */
+    getSceneInitializationProgress(): number;
+    /**
+     * Returns the current configuration object applied to the scene.
+     */
+    getCurrentConfiguration(): PreviewOptions | undefined;
+    /**
+     * Takes a screenshot of the scene using a given
+     * camera animation otherwise using the existing orientation
+     * of the camera in the scene. A resolution must be provided
+     * to render the scene at.
+     */
+    renderSceneScreenshot(resolution: number, cameraAnimation: CameraAnimation): Promise<string>;
+    /**
+     * Returns true when the current configuration allows the user
+     * to rotate around the product.
+     */
+    orbitEnabled(): boolean;
+    /**
+     * When called will trigger the internal engine to match the current
+     * canvas size. This ensures the image renders correctly in the view and
+     * also prevents performance problems.
+     */
+    fireResizeEvent(): void;
+    /**
+     * A callback when the user clicks in the scene and a material is hit.
+     */
+    onMaterialSelected(cb: (material: MaterialHandle) => void): void;
+    /**
+     * Designed for use when utilizing the 3D preview in an editor format.
+     * List named materials that are available in the scene.
+     */
+    listMaterials(): readonly MaterialHandle[];
+    /**
+     * Designed for use when utilizing the 3D preview in an editor format.
+     * Given a list of material names, highlights the associated meshes in the scene.
+     */
+    setHighlights(materials: readonly MaterialHandle[], color?: readonly [number, number, number]): void;
+};
+/**
+ * Details relating to a model for use in the preview.
+ */
+type ModelDetails = {
+    readonly model?: string;
+    readonly contextService: RenderableContextService;
+};
+/**
+ * Represents a service capable of managing and returning contexts that
+ * can be used for rendering to textures in the 3D preview.
+ */
+type RenderableContextService = {
+    /**
+     * Returns all managed renderable contexts.
+     */
+    getAll(): ReadonlyMap<string, RenderableContext>;
+};
+/**
+ * A renderable context represents the relationship of a texture in the 3D preview
+ * with an external canvas. This context allows external clients to render to a texture
+ * in the 3D preview with a simple interface.
+ */
+type RenderableContext = {
+    /**
+     * A unique identifier for this renderable context.
+     */
+    getID(): string;
+    /**
+     * A name for this renderable.
+     */
+    getName(): string;
+    /**
+     * Sets the render context associated to this renderable.
+     * @param ctx The context to use for rendering.
+     */
+    setStaticContext(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Get the render context associated to this renderable.
+     */
+    getStaticContext(): CanvasRenderingContext2D | undefined;
+    /**
+     * Sets whether or not this renderable is dirty and will need re-rendering.
+     * @param value The new value
+     */
+    setStaticContextDirty(value: boolean): void;
+    /**
+     * When this context has been set as dirty, returns true.
+     */
+    getStaticContextDirty(): boolean;
+    /**
+     * A timestamp for the last successful render of the context.
+     */
+    getLastCompletedStaticRender(): number | undefined;
+};
+/**
+ * Represents a handle to a material in the 3D scene. The underlying complexity of materials is abstracted
+ * away so the client doesn't need to know anything more than the ID they're given and the name.
+ */
+type MaterialHandle = {
+    /**
+     * The identifier for the material.
+     */
+    readonly id: string;
+    /**
+     * The human readable name for the material.
+     */
+    readonly name: string;
+};
+/**
+ * Settings related to the 3D preview.
+ */
+type PreviewOptions = {
+    /**
+     * The color expected to be seen in the background of the product. Expects a hexadecimal value.
+     */
+    readonly backgroundColor?: string;
+    /**
+     * Image to be used as a background when running withh transparency, the image
+     * will be scaled and centered to fill the preview based on aspect ratio.
+     */
+    readonly backgroundImage?: string;
+    /**
+     * The closest zoom the camera can achieve to the product.
+     */
+    readonly maxZoomOverride?: number;
+    /**
+     * The furthest zoom the camera can achieve to the product.
+     */
+    readonly minZoomOverride?: number;
+    /**
+     * The environment file used to calculate product lighting.
+     */
+    readonly environmentFile?: string;
+    /**
+     * The lowest point, vertically, that the camera can rotate to.
+     * https://doc.babylonjs.com/divingDeeper/cameras/camera_introduction
+     */
+    readonly lowerBetaLimitDeg?: number;
+    /**
+     * The highest point, vertically, that the camera can rotate to.
+     * https://doc.babylonjs.com/divingDeeper/cameras/camera_introduction
+     */
+    readonly upperBetaLimitDeg?: number;
+    /**
+     * The leftmost point, horizontally, that the camera can rotate to.
+     * https://doc.babylonjs.com/divingDeeper/cameras/camera_introduction
+     */
+    readonly lowerAlphaLimitDeg?: number;
+    /**
+     * The rightmost point, horizontally, that the camera can rotate to.
+     * https://doc.babylonjs.com/divingDeeper/cameras/camera_introduction
+     */
+    readonly upperAlphaLimitDeg?: number;
+    /**
+     * When set the product while rotate slowly
+     */
+    readonly autoRotation?: boolean;
+    /**
+     * Time in milliseconds before the product starts rotating after a user input has taken control.
+     */
+    readonly idleTimeBeforeRotation?: number;
+    /**
+     * When set the 3D preview won't attempt to orient the product automatically to its front view at load.
+     */
+    readonly disableAutomaticOrientation?: boolean;
+    /**
+     * When true the action bar won't be displayed to the user.
+     */
+    readonly disableActionBar?: boolean;
+    /**
+     * When set, mousing over the model in this preview will highlight the associated mesh/material.
+     * When layout contexts are provided, only the materials with matching names will highlight.
+     */
+    readonly highlightOnMaterialHover?: boolean;
+    /**
+     * Sets the color of highlights when enabled. Expects hexadecimal value.
+     */
+    readonly highlightColor?: string;
+};
+/**
+ * Defines the different behaviors supported by the camera system
+ * for control when viewing a product.
+ */
+enum ProductCameraRig {
+    Orbit = 0,
+    Pan = 1
+}
+/**
+ * Identical to CameraAnimation typing, however the
+ * target is always available and hence is not optional.
+ */
+type CameraPose = {
+    readonly lonDeg: number;
+    readonly radius: number;
+    readonly latDeg: number;
+    readonly target: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    };
+};
+type LoadProgressEventData = {
+    /**
+     * The total load value of the scene, this is an average of all
+     * 'in progress' loading events. when all events are fully loaded this value will be 100.
+     */
+    readonly loadValue: number;
+    /**
+     * This value is true when the base model and scene have been initialized.
+     */
+    readonly sceneInitialized: boolean;
+};
+declare class OptionService {
+    /**
+     * Returns a promise that resolves once all options required for a given workflow
+     * have been loaded and cached ready for use.
+     * @param workflow The workflow to load options for.
+     */
+    cacheRequiredOptions(workflow: Workflow): Promise<void>;
+    /**
+     * Allows for retrieving an option, returns the option from a cache if possible.
+     * @param server The server service for making the request.
+     * @param id The option ID to be retrieved.
+     */
+    getLocalOrFromServer(server: ServerService, id: string): Promise<IServerModel<OptionResource>>;
+    /**
+     * Returns an option from the cache, or null
+     * @param id The ID to search for.
+     */
+    getLocalOrUndefined(id?: string): IServerModel<OptionResource>;
+    getAssetTileImageForVariant(variant: VariantResource): Promise<string>;
+    getDefaultVariant(option: OptionResource): VariantResource | undefined;
+    getDisplayImageSource: (variant?: VariantResource) => undefined | string;
+    /**
+     * Returns the first variant marked as selected. This is used by most steps.
+     */
+    getSelectedVariant: (option: OptionResource | undefined, selectedVariantIds: string[]) => VariantResource | undefined;
+    /**
+     * Returns all selected variants. This is used by the question step as multiple selections can be made.
+     */
+    getSelectedVariants: (option: OptionResource | undefined, selectedVariantIds: string[]) => VariantResource[];
+}
+export const optionService: OptionService;
+export const CommandContextContext: import("react").Context<_CommandContext1>;
+export const useLayouts: () => {
+    commandDispatcher: (command: CanvasCommand) => void;
+    getLayoutById: (id: string) => _LayoutData1;
+    getAllLayouts: () => _LayoutData1[];
+    getReducerState: () => CommandState;
+    lastUpdated: Date;
+    flattenSequence: (sequenceId: string, initialState: _LayoutsState1) => void;
+};
+export type CommandDispatcher = (command: CanvasCommand) => void;
+export type LayoutGetter = (layoutId: string) => _LayoutData1;
+export type LayoutsGetter = () => _LayoutData1[];
+enum ElementEventType {
+    Translate = "Translate",
+    Rotate = "Rotate",
+    Resize = "Resize"
+}
+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;
+};
+enum EditorSubMenu {
+    None = "None",
+    FrameAdjustment = "FrameAdjustment",
+    FinalizeDesign = "FinalizeDesign"
+}
+interface UIState {
+}
+/**
+ * This context stores global state for
+ */
+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 maxiumum zoom possible based on current canvas content.
+     */
+    maxZoom: number;
+    /**
+     * The current measurement system used for display of coordinates and dimensions.
+     */
+    units: UnitOfMeasurement;
+    /**
+     * 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) => {
+    layoutId: string;
+    selectedElement: any;
+    zoom: number;
+    maxZoom: number;
+    units: UnitOfMeasurement;
+    subMenu: EditorSubMenu;
+    activeModifierKeys: any[];
+    metaPressed: boolean;
+    elementEvent: any;
+    scrolledMovement: boolean;
+};
+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;
+        zoom: number;
+        maxZoom: number;
+        units: UnitOfMeasurement;
+        subMenu: EditorSubMenu;
+        activeModifierKeys: KeyEvent[];
+        metaPressed: boolean;
+        elementEvent?: ElementEvent;
+        scrolledMovement: boolean;
+    };
+}
+export const useEditorState: () => {
+    uiDispatcher: Dispatch<UICommand>;
+    state: AdvancedEditorState;
+};
+/**
+ * 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<{
+    color?: string;
+    guidelineColor?: string;
+    borderRadius?: number;
+    handleContextMenu?: (event: MouseEvent) => void;
+    onElementSelected?: (id: string | undefined, element: PointerEvent) => void;
+}>;
+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;
+    getMap(key: string): Map<any, any> | undefined;
+    setMap(key: string, val: Map<any, any>): void;
+}
+export const persistenceService: StorageService;
+/**
+ * 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.
+ */
+interface StepHandle {
+    /**
+     * Gets the currently selected variant, or undefined if no variant is selected.
+     */
+    getCurrentVariant(): any;
+    /**
+     * Returns a list of valid variants for this step.
+     */
+    getAvailableVariants(): Promise<VariantResource[]>;
+    /**
+     * Selects a specific variant for this step.
+     */
+    selectVariant(variant: VariantResource): any;
+}
+/**
+ * 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 {
+    /**
+     * State related to the design of the user.
+     */
+    getCommandContext(): _CommandContext1;
+    /**
+     * 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 | undefined;
+    /**
+     * Returns the step matching a given name, undefined if not found.
+     * @param name The name the step must match.
+     */
+    getStepByName(name: string): StepHandle | undefined;
+    /**
+     * Returns all steps matching a specific type in the workflow. These steps
+     * may be across multiple scenes and may or may not be active based on condition state.
+     */
+    getStepsByType(type: StepType): StepHandle[];
+    /**
+     * Creates a data URL preview for the current design.
+     */
+    createPreviewImage(): Promise<string>;
+    /**
+     * To be called when the workflow experience is considered completed by the user.
+     * @param product
+     * @param onProgressUpdate Progress callback for finalizing the design.
+     * @param selections
+     * @param metadata
+     */
+    onDesignFinished(product: Product, onProgressUpdate: DesignCreationProgressUpdate, selections: WorkflowSelections, metadata?: WorkflowMetadata | undefined): Promise<DesignCreationMessage>;
+}
+/**
+ * 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.
+     */
+    bulk?: boolean;
+    useUncachedEndpoints?: boolean;
+}
+/**
+ * The Spiff Commerce Javascript Client. Required for
+ * creating workflow experiences.
+ */
+export class Client {
+    constructor(options: ClientOptions);
+    /**
+     * Initialize the client from an integration product.
+     * @param integrationProductId The integration product to use.
+     */
+    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.
+     */
+    initFromTransaction(transactionId: string): Promise<void>;
+    /**
+     * Creates a new instance of WorkflowExperience. A high level wrapper for workflows.
+     * @param workflowId The id of the workflow to be run.
+     * @param workflowState An existing workflow state if available.
+     * @param previewServiceConstructor A function called during initialization. Takes a class implementing ThreeDPreviewService in return.
+     * @returns A workflow experience configured as requested.
+     */
+    getWorkflowExperience(workflowId?: string, workflowState?: string, previewServiceConstructor?: (workflow: Workflow) => _ThreeDPreviewService1): Promise<WorkflowExperience>;
+    /**
+     * @returns The preview service that was provided during construction.
+     */
+    getPreviewService(): import("types")._ThreeDPreviewService1;
+    /**
+     * @returns The product associated with this client.
+     */
+    getProduct(): Product;
+    /**
+     * @returns The transaction associated with this client.
+     */
+    getTransaction(): Transaction;
+}
+export { CommandContext };
+export { CreateElementCommand, TextChangeCommand, FontAlignmentCommand, FontColorCommand, LayoutElementFactory };
+export { LayoutElement, ImageElement, TextboxElement, TextStepData, LayoutData, LayoutsState };
+export { SpiffCommerce3DPreviewService };
+
+//# sourceMappingURL=types.d.ts.map