@bubblydoo/uxp-toolkit 0.0.8 → 0.0.10

package/dist/commands-library/index.js

@@ -5,11 +5,11 @@ import {
   createGetDocumentHasBackgroundLayerCommand,
   createGetLayerCommand,
   createMultiGetDocumentCommand
-} from "../chunk-3CLJMC63.js";
+} from "../chunk-JBXCIUBZ.js";
 
-// src/commands-library/selectLayer.ts
+// src/commands-library/addLayerToSelection.ts
 import { z } from "zod";
-function createSelectLayerCommand(layerRef) {
+function createAddLayerToSelectionCommand(layerRef, previousLayerRef) {
   return createCommand({
     modifying: true,
     descriptor: {
@@ -24,176 +24,172 @@ function createSelectLayerCommand(layerRef) {
           _id: layerRef.docId
         }
       ],
+      selectionModifier: {
+        _enum: "selectionModifierType",
+        _value: "addToSelection"
+      },
       makeVisible: false,
-      layerID: [layerRef.id],
-      _isCommand: false
+      layerID: [layerRef.id, previousLayerRef.id],
+      _isCommand: true
     },
     schema: z.unknown()
   });
 }
 
-// src/commands-library/addLayerToSelection.ts
+// src/commands-library/applyLayerMask.ts
 import { z as z2 } from "zod";
-function createAddLayerToSelectionCommand(layerRef, previousLayerRef) {
+function createSelectLayerMaskCommand(layerId) {
   return createCommand({
     modifying: true,
     descriptor: {
       _obj: "select",
       _target: [
         {
-          _ref: "layer",
-          _id: layerRef.id
+          _ref: "channel",
+          _enum: "channel",
+          _value: "mask"
         },
         {
-          _ref: "document",
-          _id: layerRef.docId
+          _ref: "layer",
+          _id: layerId
         }
       ],
-      selectionModifier: {
-        _enum: "selectionModifierType",
-        _value: "addToSelection"
-      },
-      makeVisible: false,
-      layerID: [layerRef.id, previousLayerRef.id],
-      _isCommand: true
+      makeVisible: false
+    },
+    schema: z2.unknown()
+  });
+}
+function createDeleteChannelAndApplyCommand() {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "delete",
+      _target: [
+        {
+          _ref: "channel",
+          _enum: "ordinal",
+          _value: "targetEnum"
+        }
+      ],
+      apply: true
     },
     schema: z2.unknown()
   });
 }
 
-// src/commands-library/expandFolder.ts
+// src/commands-library/convertMode.ts
 import { z as z3 } from "zod";
-function createExpandFolderCommand(layerRef) {
+function createConvertModeCommand(depth) {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "set",
-      _target: {
-        _ref: [
-          { _property: "layerSectionExpanded" },
-          { _ref: "layer", _id: layerRef.id },
-          { _ref: "document", _id: layerRef.docId }
-        ]
-      },
-      to: true
+      _obj: "convertMode",
+      depth
     },
     schema: z3.unknown()
   });
 }
 
-// src/commands-library/renameLayer.ts
+// src/commands-library/createColorLookupAdjustmentLayer.ts
 import { z as z4 } from "zod";
-function createRenameLayerCommand(layerRef, newName) {
+function createColorLookupAdjustmentLayerCommand() {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "set",
-      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
-      to: { _obj: "layer", name: newName }
+      _obj: "make",
+      _target: [
+        {
+          _ref: "adjustmentLayer"
+        }
+      ],
+      using: {
+        _obj: "adjustmentLayer",
+        type: {
+          _class: "colorLookup"
+        }
+      },
+      _isCommand: true
     },
     schema: z4.unknown()
   });
 }
 
-// src/commands-library/rasterizeLayerStyle.ts
+// src/commands-library/expandFolder.ts
 import { z as z5 } from "zod";
-function createRasterizeLayerStyleCommand(psLayerRef) {
+function createExpandFolderCommand(layerRef) {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "rasterizeLayer",
-      _target: [{ _ref: "layer", _id: psLayerRef.id }, { _ref: "document", _id: psLayerRef.docId }],
-      what: { _enum: "rasterizeItem", _value: "layerStyle" }
+      _obj: "set",
+      _target: {
+        _ref: [
+          { _property: "layerSectionExpanded" },
+          { _ref: "layer", _id: layerRef.id },
+          { _ref: "document", _id: layerRef.docId }
+        ]
+      },
+      to: true
     },
     schema: z5.unknown()
   });
 }
 
-// src/commands-library/rasterizeVectorMask.ts
+// src/commands-library/exportLUTs.ts
 import { z as z6 } from "zod";
-function createRasterizeVectorMaskCommand() {
+function createExportLUTsCommand(path, options = {}) {
+  const {
+    description = "Exported LUT",
+    gridPoints = 32,
+    copyright = "Copyright",
+    exportFormats = ["CUBE", "ICC", "3DL", "CSP"],
+    lowercaseExtension = false
+  } = options;
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "rasterizeLayer",
-      _target: [
-        {
-          _ref: "layer",
-          _enum: "ordinal",
-          _value: "targetEnum"
-        }
-      ],
-      what: {
-        _enum: "rasterizeItem",
-        _value: "vectorMask"
+      _obj: "export",
+      using: {
+        _obj: "$lut ",
+        $fpth: path,
+        $dscr: description,
+        $gPts: gridPoints,
+        copyright,
+        $wICC: exportFormats.includes("ICC"),
+        $w3DL: exportFormats.includes("3DL"),
+        $wCUB: exportFormats.includes("CUBE"),
+        $wCSP: exportFormats.includes("CSP"),
+        $lcFE: lowercaseExtension
       }
     },
     schema: z6.unknown()
   });
 }
 
-// src/commands-library/applyLayerMask.ts
+// src/commands-library/hasVectorMask.ts
 import { z as z7 } from "zod";
-function createSelectLayerMaskCommand(layerId) {
+function createHasVectorMaskCommand(layerId) {
   return createCommand({
-    modifying: true,
+    modifying: false,
     descriptor: {
-      _obj: "select",
+      _obj: "get",
       _target: [
         {
-          _ref: "channel",
-          _enum: "channel",
-          _value: "mask"
+          _property: "hasVectorMask"
         },
         {
           _ref: "layer",
           _id: layerId
         }
-      ],
-      makeVisible: false
-    },
-    schema: z7.unknown()
-  });
-}
-function createDeleteChannelAndApplyCommand() {
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "delete",
-      _target: [
-        {
-          _ref: "channel",
-          _enum: "ordinal",
-          _value: "targetEnum"
-        }
-      ],
-      apply: true
-    },
-    schema: z7.unknown()
-  });
-}
-
-// src/commands-library/removeLayerMask.ts
-import { z as z8 } from "zod";
-function createDeleteChannelCommand() {
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "delete",
-      _target: [
-        {
-          _ref: "channel",
-          _enum: "ordinal",
-          _value: "targetEnum"
-        }
       ]
     },
-    schema: z8.unknown()
+    schema: z7.object({
+      hasVectorMask: z7.boolean()
+    })
   });
 }
 
 // src/commands-library/loadLayerMaskAsSelection.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 function createLoadLayerMaskAsSelectionCommand(layerId) {
   return createCommand({
     modifying: true,
@@ -219,72 +215,120 @@ function createLoadLayerMaskAsSelectionCommand(layerId) {
         ]
       }
     },
+    schema: z8.unknown()
+  });
+}
+
+// src/commands-library/rasterizeLayerStyle.ts
+import { z as z9 } from "zod";
+function createRasterizeLayerStyleCommand(psLayerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "rasterizeLayer",
+      _target: [{ _ref: "layer", _id: psLayerRef.id }, { _ref: "document", _id: psLayerRef.docId }],
+      what: { _enum: "rasterizeItem", _value: "layerStyle" }
+    },
     schema: z9.unknown()
   });
 }
 
-// src/commands-library/hasVectorMask.ts
+// src/commands-library/rasterizeVectorMask.ts
 import { z as z10 } from "zod";
-function createHasVectorMaskCommand(layerId) {
+function createRasterizeVectorMaskCommand() {
   return createCommand({
-    modifying: false,
+    modifying: true,
     descriptor: {
-      _obj: "get",
+      _obj: "rasterizeLayer",
       _target: [
-        {
-          _property: "hasVectorMask"
-        },
         {
           _ref: "layer",
-          _id: layerId
+          _enum: "ordinal",
+          _value: "targetEnum"
         }
-      ]
+      ],
+      what: {
+        _enum: "rasterizeItem",
+        _value: "vectorMask"
+      }
     },
-    schema: z10.object({
-      hasVectorMask: z10.boolean()
-    })
+    schema: z10.unknown()
   });
 }
 
-// src/commands-library/convertMode.ts
+// src/commands-library/removeLayerMask.ts
 import { z as z11 } from "zod";
-function createConvertModeCommand(depth) {
+function createDeleteChannelCommand() {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "convertMode",
-      depth
+      _obj: "delete",
+      _target: [
+        {
+          _ref: "channel",
+          _enum: "ordinal",
+          _value: "targetEnum"
+        }
+      ]
     },
     schema: z11.unknown()
   });
 }
 
-// src/commands-library/createColorLookupAdjustmentLayer.ts
+// src/commands-library/renameLayer.ts
 import { z as z12 } from "zod";
-function createColorLookupAdjustmentLayerCommand() {
+function createRenameLayerCommand(layerRef, newName) {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "make",
+      _obj: "set",
+      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
+      to: { _obj: "layer", name: newName }
+    },
+    schema: z12.unknown()
+  });
+}
+
+// src/commands-library/renderGrid.ts
+import { z as z13 } from "zod";
+function createRenderGridCommand(gridPoints) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "$3grd",
+      $grdP: gridPoints
+    },
+    schema: z13.unknown()
+  });
+}
+
+// src/commands-library/selectLayer.ts
+import { z as z14 } from "zod";
+function createSelectLayerCommand(layerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "select",
       _target: [
         {
-          _ref: "adjustmentLayer"
+          _ref: "layer",
+          _id: layerRef.id
+        },
+        {
+          _ref: "document",
+          _id: layerRef.docId
         }
       ],
-      using: {
-        _obj: "adjustmentLayer",
-        type: {
-          _class: "colorLookup"
-        }
-      },
-      _isCommand: true
+      makeVisible: false,
+      layerID: [layerRef.id],
+      _isCommand: false
     },
-    schema: z12.unknown()
+    schema: z14.unknown()
   });
 }
 
 // src/commands-library/set3DLUTColorLookup.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function createSet3DLUTColorLookupCommand(options) {
   const {
     lutPath,
@@ -330,50 +374,6 @@ function createSet3DLUTColorLookupCommand(options) {
       },
       _isCommand: true
     },
-    schema: z13.unknown()
-  });
-}
-
-// src/commands-library/exportLUTs.ts
-import { z as z14 } from "zod";
-function createExportLUTsCommand(path, options = {}) {
-  const {
-    description = "Exported LUT",
-    gridPoints = 32,
-    copyright = "Copyright",
-    exportFormats = ["CUBE", "ICC", "3DL", "CSP"],
-    lowercaseExtension = false
-  } = options;
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "export",
-      using: {
-        _obj: "$lut ",
-        $fpth: path,
-        $dscr: description,
-        $gPts: gridPoints,
-        copyright,
-        $wICC: exportFormats.includes("ICC"),
-        $w3DL: exportFormats.includes("3DL"),
-        $wCUB: exportFormats.includes("CUBE"),
-        $wCSP: exportFormats.includes("CSP"),
-        $lcFE: lowercaseExtension
-      }
-    },
-    schema: z14.unknown()
-  });
-}
-
-// src/commands-library/renderGrid.ts
-import { z as z15 } from "zod";
-function createRenderGridCommand(gridPoints) {
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "$3grd",
-      $grdP: gridPoints
-    },
     schema: z15.unknown()
   });
 }

package/dist/index.d.ts

@@ -1,70 +1,25 @@
-import { c as createModifyingBatchPlayContext, P as PsLayerRef } from './psLayerRef-OY3h7srv.js';
-export { C as CorrectBatchPlayOptions, U as UTCommandBase, a as UTCommandModifying, b as UTCommandNonModifying, d as UTCommandResult, e as batchPlay, f as batchPlayCommand, g as batchPlayCommands, h as createCommand, i as createMultiGetDocumentCommand } from './psLayerRef-OY3h7srv.js';
-import * as photoshop_dom_Document from 'photoshop/dom/Document';
-import { Document } from 'photoshop/dom/Document';
-import { Layer } from 'photoshop/dom/Layer';
-import { z } from 'zod';
+import { c as createModifyingBatchPlayContext, P as PsLayerRef } from './psLayerRef-CGbTO4a5.js';
+export { C as CorrectBatchPlayOptions, U as UTCommandBase, a as UTCommandModifying, b as UTCommandNonModifying, d as UTCommandResult, e as batchPlay, f as batchPlayCommand, g as batchPlayCommands, h as createCommand, i as createMultiGetDocumentCommand } from './psLayerRef-CGbTO4a5.js';
+import * as photoshop from 'photoshop';
+import { ExecutionContext, ExecuteAsModalOptions, Document, Layer } from 'photoshop';
 import ErrorStackParser from 'error-stack-parser';
-import 'photoshop/dom/CoreModules';
-import 'photoshop';
-
-type CorrectExecutionContext = {
-    /**
-     * True if user has cancelled the modal interaction.
-     *
-     * User can cancel by hitting the Escape key, or by pressing the "Cancel" button in the progress bar.
-     */
-    isCancelled: boolean;
-    /**
-     * If assigned a method, it will be called when user cancels the modal interaction.
-     */
-    onCancel: () => void;
-    /**
-     * Call this to customize the progress bar.
-     */
-    reportProgress: (info: {
-        value: number;
-        commandName?: string;
-    }) => void;
-    /**
-     * Use the methods in here to control Photoshop state
-     */
-    hostControl: {
-        /**
-         * Call to suspend history on a target document, returns the suspension ID which can be used for resumeHistory
-         */
-        suspendHistory: (info: {
-            documentID: number;
-            name: string;
-        }) => Promise<number>;
-        /**
-         * Call to resume history on a target document
-         */
-        resumeHistory: (suspensionID: number, commit: boolean) => Promise<void>;
-        /** Register a document to be closed when the modal scope exits. See below for details. */
-        registerAutoCloseDocument: (documentID: number) => Promise<void>;
-        /** Unregister a document from being closed when the modal scope exits */
-        unregisterAutoCloseDocument: (documentID: number) => Promise<void>;
-    };
-};
-type CorrectExecuteAsModalOptions = {
-    commandName: string;
-    interactive?: boolean;
-    timeOut?: number;
-};
-type ExtendedExecutionContext = Omit<CorrectExecutionContext, "onCancel"> & ReturnType<typeof createModifyingBatchPlayContext> & {
+import { Entry, File, Folder } from 'uxp';
+import { z } from 'zod';
+
+type ExtendedExecutionContext = Omit<ExecutionContext, 'onCancel'> & ReturnType<typeof createModifyingBatchPlayContext> & {
     signal: AbortSignal;
 };
-type OptionsWithoutCommandName = Omit<CorrectExecuteAsModalOptions, "commandName">;
+type OptionsWithoutCommandName = Omit<ExecuteAsModalOptions, 'commandName'>;
 declare function executeAsModal<T>(commandName: string, fn: (executionContext: ExtendedExecutionContext) => Promise<T>, opts?: OptionsWithoutCommandName): Promise<T>;
 
-type SuspendHistoryContext = {};
+interface SuspendHistoryContext {
+}
 declare function suspendHistory<T>(document: Document, historyStateName: string, fn: (context: SuspendHistoryContext) => Promise<T>): Promise<T>;
 
 type CombinedFn<T> = (executionContext: ExtendedExecutionContext, suspendHistoryContext: SuspendHistoryContext) => Promise<T>;
-declare const executeAsModalAndSuspendHistory: <T>(commandName: string, document: Document, fn: CombinedFn<T>) => Promise<T>;
+declare function executeAsModalAndSuspendHistory<T>(commandName: string, document: Document, fn: CombinedFn<T>): Promise<T>;
 
-declare const getFlattenedDomLayersList: (layers: Layer[]) => Layer[];
+declare function getFlattenedDomLayersList(layers: Layer[]): Layer[];
 
 type Tree<TRef = unknown> = {
     ref: TRef;
@@ -72,20 +27,29 @@ type Tree<TRef = unknown> = {
     children?: Tree<TRef>;
 }[];
 
-declare const photoshopDomLayersToTree: (layers: Layer[]) => Tree<Layer>;
+declare function photoshopDomLayersToTree(layers: Layer[]): Tree<Layer>;
 
-declare function openFileByPath(path: string): Promise<photoshop_dom_Document.Document>;
+type BasicStackFrame = Pick<ErrorStackParser.StackFrame, 'functionName' | 'fileName' | 'lineNumber' | 'columnNumber'>;
+declare function parseUxpErrorSourcemaps(error: Error, opts?: {
+    unsourcemappedHeaderLines?: number;
+}): Promise<BasicStackFrame[]>;
+declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
 
-declare function flattenTree<T>(tree: Tree<T>): Tree<T>[0][];
+declare function isFile(entry: Entry): entry is File;
+declare function isFolder(entry: Entry): entry is Folder;
 
-declare function mapTree<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+declare function openFileByPath(path: string): Promise<photoshop.Document>;
 
-declare function mapTreeRef<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+declare function flattenTree<T>(tree: Tree<T>): Tree<T>[0][];
 
-type LayerRef = {
+interface LayerRef {
     id: number;
     docId: number;
-};
+}
+
+declare function mapTree<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+
+declare function mapTreeRef<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
 
 declare function photoshopGetApplicationInfo(): Promise<{
     active: boolean;
@@ -127,7 +91,7 @@ declare const uxpEntrypointsSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 
-declare const getDocumentLayerDescriptors: (documentId: number) => Promise<{
+declare function getDocumentLayerDescriptors(documentId: number): Promise<{
     docId: number;
     name: string;
     layerID: number;
@@ -154,9 +118,9 @@ type LayerDescriptor = Awaited<ReturnType<typeof getDocumentLayerDescriptors>>[n
 
 declare function getLayerEffects(layerRef: PsLayerRef): Promise<Record<string, boolean>>;
 
-type UTLayerKind = "pixel" | "adjustment-layer" | "text" | "curves" | "smartObject" | "video" | "group" | "threeD" | "gradientFill" | "pattern" | "solidColor" | "background";
-type UTBlendMode = "normal" | "dissolve" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "blendSubtraction" | "blendDivide" | "hue" | "saturation" | "color" | "luminosity" | "passThrough";
-type UTLayerBuilder = {
+type UTLayerKind = 'pixel' | 'adjustment-layer' | 'text' | 'curves' | 'smartObject' | 'video' | 'group' | 'threeD' | 'gradientFill' | 'pattern' | 'solidColor' | 'background';
+type UTBlendMode = 'normal' | 'dissolve' | 'darken' | 'multiply' | 'colorBurn' | 'linearBurn' | 'darkerColor' | 'lighten' | 'screen' | 'colorDodge' | 'linearDodge' | 'lighterColor' | 'overlay' | 'softLight' | 'hardLight' | 'vividLight' | 'linearLight' | 'pinLight' | 'hardMix' | 'difference' | 'exclusion' | 'blendSubtraction' | 'blendDivide' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'passThrough';
+interface UTLayerBuilder {
     name: string;
     docId: number;
     id: number;
@@ -167,29 +131,23 @@ type UTLayerBuilder = {
     isClippingMask: boolean;
     background: boolean;
     layers?: UTLayerBuilder[];
-};
-type UTLayer = Readonly<Omit<UTLayerBuilder, "layers">> & {
+}
+type UTLayer = Readonly<Omit<UTLayerBuilder, 'layers'>> & {
     layers?: UTLayer[];
 };
 declare function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]): UTLayer[];
 
-type UTLayerWithoutChildren = Omit<UTLayer, "layers">;
-declare function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren>;
-
-type UTLayerPickKeys<TKey extends keyof Omit<UTLayer, "layers">> = Pick<Omit<UTLayer, "layers">, TKey> & {
+type UTLayerPickKeys<TKey extends keyof Omit<UTLayer, 'layers'>> = Pick<Omit<UTLayer, 'layers'>, TKey> & {
     layers?: UTLayerPickKeys<TKey>[];
 };
 
-type MinimalUTLayer = UTLayerPickKeys<"effects" | "visible" | "isClippingMask" | "kind" | "blendMode" | "name">;
+type MinimalUTLayer = UTLayerPickKeys<'effects' | 'visible' | 'isClippingMask' | 'kind' | 'blendMode' | 'name'>;
 declare function utLayersToText(tree: MinimalUTLayer[], depth?: number): string;
 
+type UTLayerWithoutChildren = Omit<UTLayer, 'layers'>;
+declare function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren>;
+
 declare function utLayerToDomLayer(layer: UTLayer): Layer;
 declare function utLayersToDomLayers(layers: UTLayer[]): Layer[];
 
-type BasicStackFrame = Pick<ErrorStackParser.StackFrame, "functionName" | "fileName" | "lineNumber" | "columnNumber">;
-declare function parseUxpErrorSourcemaps(error: Error, opts?: {
-    unsourcemappedHeaderLines?: number;
-}): Promise<BasicStackFrame[]>;
-declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
-
-export { type BasicStackFrame, type CorrectExecuteAsModalOptions, type CorrectExecutionContext, type ExtendedExecutionContext, type LayerDescriptor, type LayerRef, PsLayerRef, type SuspendHistoryContext, type Tree, type UTLayer, type UTLayerPickKeys, type UTLayerWithoutChildren, copyToClipboard, createModifyingBatchPlayContext, executeAsModal, executeAsModalAndSuspendHistory, flattenTree, getBasicStackFrameAbsoluteFilePath, getDocumentLayerDescriptors, getFlattenedDomLayersList, getLayerEffects, mapTree, mapTreeRef, openFileByPath, parseUxpErrorSourcemaps, photoshopDomLayersToTree, photoshopGetApplicationInfo, photoshopLayerDescriptorsToUTLayers, readFromClipboard, suspendHistory, utLayerToDomLayer, utLayersToDomLayers, utLayersToTree, utLayersToText as utTreeToText, uxpEntrypointsSchema };
+export { type BasicStackFrame, type ExtendedExecutionContext, type LayerDescriptor, type LayerRef, PsLayerRef, type SuspendHistoryContext, type Tree, type UTLayer, type UTLayerPickKeys, type UTLayerWithoutChildren, copyToClipboard, createModifyingBatchPlayContext, executeAsModal, executeAsModalAndSuspendHistory, flattenTree, getBasicStackFrameAbsoluteFilePath, getDocumentLayerDescriptors, getFlattenedDomLayersList, getLayerEffects, isFile, isFolder, mapTree, mapTreeRef, openFileByPath, parseUxpErrorSourcemaps, photoshopDomLayersToTree, photoshopGetApplicationInfo, photoshopLayerDescriptorsToUTLayers, readFromClipboard, suspendHistory, utLayerToDomLayer, utLayersToDomLayers, utLayersToTree, utLayersToText as utTreeToText, uxpEntrypointsSchema };