@aics/agave-webclient 1.6.1

package/es/commandbuffer.js

@@ -0,0 +1,232 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+// types:
+//   FLOAT32(f)
+//   INT32(i)
+//   STRING(s)=int32 and array of bytes
+//   FLOAT32ARRAY=int32 and array of floats
+//   INT32ARRAY=int32 and array of int32s
+var types = {
+  I32: 4,
+  F32: 4,
+  S: -1,
+  F32A: -1,
+  I32A: -1
+};
+// command id will be int32 to future-proof it.
+// note that the server needs to know these signatures too.
+export var COMMANDS = {
+  // tell server to identify this session?
+  SESSION: [0, "S"],
+  // tell server where files might be (appends to existing)
+  ASSET_PATH: [1, "S"],
+  // load a volume (DEPRECATED)
+  LOAD_OME_TIF: [2, "S"],
+  // set camera pos
+  EYE: [3, "F32", "F32", "F32"],
+  // set camera target pt
+  TARGET: [4, "F32", "F32", "F32"],
+  // set camera up direction
+  UP: [5, "F32", "F32", "F32"],
+  APERTURE: [6, "F32"],
+  // perspective(0)/ortho(1), fov(degrees)/orthoscale(world units)
+  CAMERA_PROJECTION: [7, "I32", "F32"],
+  FOCALDIST: [8, "F32"],
+  EXPOSURE: [9, "F32"],
+  MAT_DIFFUSE: [10, "I32", "F32", "F32", "F32", "F32"],
+  MAT_SPECULAR: [11, "I32", "F32", "F32", "F32", "F32"],
+  MAT_EMISSIVE: [12, "I32", "F32", "F32", "F32", "F32"],
+  // set num render iterations
+  RENDER_ITERATIONS: [13, "I32"],
+  // (continuous or on-demand frames)
+  STREAM_MODE: [14, "I32"],
+  // request new image
+  REDRAW: [15],
+  SET_RESOLUTION: [16, "I32", "I32"],
+  DENSITY: [17, "F32"],
+  // move camera to bound and look at the scene contents
+  FRAME_SCENE: [18],
+  MAT_GLOSSINESS: [19, "I32", "F32"],
+  // channel index, 1/0 for enable/disable
+  ENABLE_CHANNEL: [20, "I32", "I32"],
+  // channel index, window, level.  (Do I ever set these independently?)
+  SET_WINDOW_LEVEL: [21, "I32", "F32", "F32"],
+  // theta, phi in degrees
+  ORBIT_CAMERA: [22, "F32", "F32"],
+  SKYLIGHT_TOP_COLOR: [23, "F32", "F32", "F32"],
+  SKYLIGHT_MIDDLE_COLOR: [24, "F32", "F32", "F32"],
+  SKYLIGHT_BOTTOM_COLOR: [25, "F32", "F32", "F32"],
+  // r, theta, phi
+  LIGHT_POS: [26, "I32", "F32", "F32", "F32"],
+  LIGHT_COLOR: [27, "I32", "F32", "F32", "F32"],
+  // x by y size
+  LIGHT_SIZE: [28, "I32", "F32", "F32"],
+  // xmin, xmax, ymin, ymax, zmin, zmax
+  SET_CLIP_REGION: [29, "F32", "F32", "F32", "F32", "F32", "F32"],
+  // x, y, z pixel scaling
+  SET_VOXEL_SCALE: [30, "F32", "F32", "F32"],
+  // channel, method
+  AUTO_THRESHOLD: [31, "I32", "I32"],
+  // channel index, pct_low, pct_high.  (Do I ever set these independently?)
+  SET_PERCENTILE_THRESHOLD: [32, "I32", "F32", "F32"],
+  MAT_OPACITY: [33, "I32", "F32"],
+  SET_PRIMARY_RAY_STEP_SIZE: [34, "F32"],
+  SET_SECONDARY_RAY_STEP_SIZE: [35, "F32"],
+  // r, g, b
+  BACKGROUND_COLOR: [36, "F32", "F32", "F32"],
+  // channel index, isovalue, isorange
+  SET_ISOVALUE_THRESHOLD: [37, "I32", "F32", "F32"],
+  // channel index, array of [stop, r, g, b, a]
+  SET_CONTROL_POINTS: [38, "I32", "F32A"],
+  // path, scene, time (DEPRECATED)
+  LOAD_VOLUME_FROM_FILE: [39, "S", "I32", "I32"],
+  // actually loads data
+  SET_TIME: [40, "I32"],
+  SET_BOUNDING_BOX_COLOR: [41, "F32", "F32", "F32"],
+  SHOW_BOUNDING_BOX: [42, "I32"],
+  TRACKBALL_CAMERA: [43, "F32", "F32"],
+  // path, scene, multiresolution level, t, channel indices, region
+  LOAD_DATA: [44, "S", "I32", "I32", "I32", "I32A", "I32A"],
+  SHOW_SCALE_BAR: [45, "I32"]
+};
+
+// strategy: add elements to prebuffer, and then traverse prebuffer to convert
+// to binary before sending?
+export var CommandBuffer = /*#__PURE__*/function () {
+  // [command, args],...
+
+  function CommandBuffer() {
+    _classCallCheck(this, CommandBuffer);
+    this.prebuffer = [];
+    this.buffer = null;
+  }
+  _createClass(CommandBuffer, [{
+    key: "prebufferToBuffer",
+    value: function prebufferToBuffer() {
+      // iterate length of prebuffer to compute size.
+      var bytesize = 0;
+      for (var i = 0; i < this.prebuffer.length; ++i) {
+        // for each command.
+
+        // one i32 for the command id.
+        bytesize += types.I32;
+        var command = this.prebuffer[i];
+        var commandCode = command[0];
+        var signature = COMMANDS[commandCode];
+        if (!signature) {
+          console.error("CommandBuffer: Unrecognized command " + commandCode);
+        }
+        var nArgsExpected = signature.length - 1;
+        // for each arg:
+        if (command.length - 1 !== nArgsExpected) {
+          console.error("BAD COMMAND: EXPECTED ".concat(nArgsExpected, " args and got ").concat(command.length - 1));
+        }
+        for (var j = 0; j < nArgsExpected; ++j) {
+          // get arg type
+          var argtype = signature[j + 1];
+          if (argtype === "S") {
+            // one int32 for string length
+            bytesize += 4;
+            // followed by one byte per char.
+            bytesize += command[j + 1].length;
+          } else if (argtype === "F32A") {
+            // one int32 for array length
+            bytesize += 4;
+            // followed by 4 bytes per float in the array
+            bytesize += 4 * command[j + 1].length;
+          } else if (argtype === "I32A") {
+            // one int32 for array length
+            bytesize += 4;
+            // followed by 4 bytes per int32 in the array
+            bytesize += 4 * command[j + 1].length;
+          } else {
+            bytesize += types[argtype];
+          }
+        }
+      }
+      // allocate arraybuffer and then fill it.
+      this.buffer = new ArrayBuffer(bytesize);
+      var dataview = new DataView(this.buffer);
+      var offset = 0;
+      var LITTLE_ENDIAN = true;
+      for (var _i = 0; _i < this.prebuffer.length; ++_i) {
+        var cmd = this.prebuffer[_i];
+        var _commandCode = cmd[0];
+        var _signature = COMMANDS[_commandCode];
+        var _nArgsExpected = _signature.length - 1;
+
+        // the numeric code for the command
+        dataview.setInt32(offset, _signature[0]);
+        offset += 4;
+        for (var _j = 0; _j < _nArgsExpected; ++_j) {
+          // get arg type
+          var _argtype = _signature[_j + 1];
+          switch (_argtype) {
+            case "S":
+              {
+                var str = cmd[_j + 1];
+                dataview.setInt32(offset, str.length);
+                offset += 4;
+                for (var k = 0; k < str.length; ++k) {
+                  dataview.setUint8(offset, str.charCodeAt(k));
+                  offset += 1;
+                }
+              }
+              break;
+            case "F32":
+              dataview.setFloat32(offset, cmd[_j + 1], LITTLE_ENDIAN);
+              offset += 4;
+              break;
+            case "I32":
+              dataview.setInt32(offset, cmd[_j + 1]);
+              offset += 4;
+              break;
+            case "F32A":
+              {
+                var flist = cmd[_j + 1];
+                dataview.setInt32(offset, flist.length);
+                offset += 4;
+                for (var _k = 0; _k < flist.length; ++_k) {
+                  dataview.setFloat32(offset, flist[_k], LITTLE_ENDIAN);
+                  offset += 4;
+                }
+              }
+              break;
+            case "I32A":
+              {
+                var ilist = cmd[_j + 1];
+                dataview.setInt32(offset, ilist.length);
+                offset += 4;
+                for (var _k2 = 0; _k2 < ilist.length; ++_k2) {
+                  dataview.setInt32(offset, ilist[_k2], LITTLE_ENDIAN);
+                  offset += 4;
+                }
+              }
+              break;
+          }
+        }
+      }
+      // result is in this.buffer
+      return this.buffer;
+    }
+
+    // commands are added by command code string name followed by appropriate
+    // signature args.
+  }, {
+    key: "addCommand",
+    value: function addCommand() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      //const args = [].slice.call(arguments);
+      // TODO: check against signature!!!
+      this.prebuffer.push([].concat(args));
+    }
+  }, {
+    key: "length",
+    value: function length() {
+      return this.prebuffer.length;
+    }
+  }]);
+  return CommandBuffer;
+}();

package/es/index.js

@@ -0,0 +1,2 @@
+import { AgaveClient } from "./agave";
+export { AgaveClient };

package/es/types/agave.d.ts

@@ -0,0 +1,380 @@
+export type JSONValue = string | number | boolean | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;
+export declare class AgaveClient {
+    private url;
+    private socket?;
+    private cb;
+    private sessionName;
+    private onOpen;
+    private onJson;
+    private onImage;
+    constructor(url?: string, rendermode?: string, onOpen?: () => void, onJson?: (_json: JSONValue) => void, onImage?: (_data: Blob) => void);
+    connect(): Promise<unknown>;
+    isReady(): boolean;
+    disconnect(): void;
+    /**
+     * Set the current session name.  Use the full path to the name of the output
+     * image here.
+     *
+     * @param name This name is the full path to the output image, ending in .png or .jpg.
+     * Make sure the directory has already been created.
+     *
+     */
+    session(name: string): void;
+    /**
+     * Sets a search path for volume files. NOT YET IMPLEMENTED.
+     *
+     * @param name This name is the path where volume images are located.
+     */
+    assetPath(name: string): void;
+    /**
+     * Set the viewer camera position. Default is (500,500,500).
+     *
+     * @param x The x coordinate
+     * @param y The y coordinate
+     * @param z The z coordinate
+     */
+    eye(x: number, y: number, z: number): void;
+    /**
+     * Set the viewer target position. This is a point toward which we are looking.
+     * Default is (0,0,0).
+     *
+     * @param x The x coordinate
+     * @param y The y coordinate
+     * @param z The z coordinate
+     */
+    target(x: number, y: number, z: number): void;
+    /**
+     * Set the viewer camera up direction.  This is a vector which should be nearly
+     * perpendicular to the view direction (target-eye), and defines the "roll" amount
+     * for the camera.
+     * Default is (0,0,1).
+     *
+     * @param x The x coordinate
+     * @param y The y coordinate
+     * @param z The z coordinate
+     */
+    up(x: number, y: number, z: number): void;
+    /**
+     * Set the viewer camera aperture size.
+     *
+     * @param x The aperture size. This is a number between 0 and 1. 0 means no defocusing will occur, like a pinhole camera.  1 means maximum defocus. Default is 0.
+     */
+    aperture(x: number): void;
+    /**
+     * Set the viewer camera projection type, along with a relevant parameter.
+     * @param projectionType 0 for Perspective, 1 for Orthographic.  Default: 0
+     * @param x If Perspective, then this is the vertical Field of View angle in degrees.
+     * If Orthographic, then this is the orthographic scale dimension.
+     * Default: 55.0 degrees. (default Orthographic scale is 0.5)
+     */
+    cameraProjection(projectionType: number, x: number): void;
+    /**
+     * Set the viewer camera focal distance
+     *
+     * @param x The focal distance.  Has no effect if aperture is 0.
+     */
+    focaldist(x: number): void;
+    /**
+     * Set the exposure level
+     *
+     * @param x The exposure level between 0 and 1. Default is 0.75.  Higher numbers are brighter.
+     */
+    exposure(x: number): void;
+    /**
+     * Set the diffuse color of a channel
+     *
+     * @param channel Which channel index, 0 based.
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     * @param a The alpha value between 0 and 1 (currently unused)
+     */
+    matDiffuse(channel: number, r: number, g: number, b: number, a: number): void;
+    /**
+     * Set the specular color of a channel (defaults to black, for no specular
+     * response)
+     *
+     * @param channel Which channel index, 0 based.
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     * @param a The alpha value between 0 and 1 (currently unused)
+     */
+    matSpecular(channel: number, r: number, g: number, b: number, a: number): void;
+    /**
+     * Set the emissive color of a channel (defaults to black, for no emission)
+     *
+     * @param channel Which channel index, 0 based.
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     * @param a The alpha value between 0 and 1 (currently unused)
+     */
+    matEmissive(channel: number, r: number, g: number, b: number, a: number): void;
+    /**
+     * Set the number of paths per pixel to accumulate.
+     *
+     * @param x How many paths per pixel. The more paths, the less noise in the image.
+     */
+    renderIterations(x: number): void;
+    /**
+     * Turn stream mode on or off.  Stream mode will send an image back to the client
+     * on each iteration up to some server-defined amount.  This mode is useful for
+     * interactive client-server applications but not for batch-mode offline rendering.
+     *
+     * @param x 0 for off, 1 for on. Default is off.
+     */
+    streamMode(x: number): void;
+    /**
+     * Tell the server to process all commands and return an image
+     * TODO , and then save the image.
+     * TODO This function will block and wait for the image to be returned.
+     * TODO The image returned will be saved automatically using the session_name.
+     * TODO: a timeout is not yet implemented.
+     */
+    redraw(): void;
+    /**
+     * Set the image resolution in pixels.
+     *
+     * @param x x resolution in pixels
+     * @param y y resolution in pixels
+     */
+    setResolution(x: number, y: number): void;
+    /**
+     * Set the scattering density.
+     *
+     * @param x The scattering density, 0-100.  Higher values will make the volume seem
+     * more opaque. Default is 8.5, which is relatively transparent.
+     */
+    density(x: number): void;
+    /**
+     * Automatically set camera parameters so that the volume fills the view.
+     * Useful when you have insufficient information to position the camera accurately.
+     */
+    frameScene(): void;
+    /**
+     * Set the channel's glossiness.
+     *
+     * @param channel Which channel index, 0 based.
+     * @param glossiness Sets the shininess, a number between 0 and 100.
+     */
+    matGlossiness(channel: number, glossiness: number): void;
+    /**
+     * Show or hide a given channel
+     *
+     * @param channel Which channel index, 0 based.
+     * @param enabled 0 to hide, 1 to show
+     */
+    enableChannel(channel: number, enabled: number): void;
+    /**
+     * Set intensity threshold for a given channel based on Window/Level
+     *
+     * @param channel Which channel index, 0 based.
+     * @param window Width of the window, from 0-1.
+     * @param level Intensity level mapped to middle of window, from 0-1
+     */
+    setWindowLevel(channel: number, window: number, level: number): void;
+    /**
+     * Rotate the camera around the volume by angle deltas
+     *
+     * @param theta polar angle in degrees
+     * @param phi azimuthal angle in degrees
+     */
+    orbitCamera(theta: number, phi: number): void;
+    /**
+     * Rotate the camera around the volume by angle deltas
+     *
+     * @param theta vertical screen angle in degrees
+     * @param phi horizontal screen angle in degrees
+     */
+    trackballCamera(theta: number, phi: number): void;
+    /**
+     * Set the "north pole" color of the sky sphere
+     *
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     */
+    skylightTopColor(r: number, g: number, b: number): void;
+    /**
+     * Set the "equator" color of the sky sphere
+     *
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     */
+    skylightMiddleColor(r: number, g: number, b: number): void;
+    /**
+     * Set the "south pole" color of the sky sphere
+     *
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     */
+    skylightBottomColor(r: number, g: number, b: number): void;
+    /**
+     * Set the position of an area light, in spherical coordinates
+     *
+     * @param index Which light to set.  Currently unused as there is only one area light.
+     * @param r The radius, as distance from the center of the volume
+     * @param theta The polar angle
+     * @param phi The azimuthal angle
+     */
+    lightPos(index: number, r: number, theta: number, phi: number): void;
+    /**
+     * Set the color of an area light. Overdrive the values higher than 1 to increase
+     * the light's intensity.
+     *
+     * @param index Which light to set.  Currently unused as there is only one area light.
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     */
+    lightColor(index: number, r: number, g: number, b: number): void;
+    /**
+     * Set the size dimensions of a rectangular area light.
+     *
+     * @param index Which light to set.  Currently unused as there is only one area light.
+     * @param x The width dimension of the area light
+     * @param y The height dimension of the area light
+     */
+    lightSize(index: number, x: number, y: number): void;
+    /**
+     * Set the axis aligned region of interest of the volume. All axis values are
+     * relative, where 0 is one extent of the volume and 1 is the opposite extent.
+     * For example, (0,1, 0,1, 0,0.5) will select the lower half of the volume's z
+     * slices.
+     *
+     * @param minx The lower x extent between 0 and 1
+     * @param maxx The higher x extent between 0 and 1
+     * @param miny The lower y extent between 0 and 1
+     * @param maxy The higher y extent between 0 and 1
+     * @param minz The lower z extent between 0 and 1
+     * @param maxz The higher z extent between 0 and 1
+     */
+    setClipRegion(minx: number, maxx: number, miny: number, maxy: number, minz: number, maxz: number): void;
+    /**
+     * Set the relative scale of the pixels in the volume. Typically this is filled in
+     * with the physical pixel dimensions from the microscope metadata.  Often the x
+     * and y scale will differ from the z scale.  Defaults to (1,1,1)
+     *
+     * @param x x scale
+     * @param y y scale
+     * @param z z scale
+     */
+    setVoxelScale(x: number, y: number, z: number): void;
+    /**
+     * Automatically determine the intensity thresholds
+     *
+     * @param channel Which channel index, 0 based.
+     * @param method Allowed values:
+     * 0: Auto2
+     * 1: Auto
+     * 2: BestFit
+     * 3: ChimeraX emulation
+     * 4: between 0.5 percentile and 0.98 percentile
+     */
+    autoThreshold(channel: number, method: number): void;
+    /**
+     * Set intensity thresholds based on percentiles of pixels to clip min and max
+     * intensity
+     *
+     * @param channel Which channel index, 0 based.
+     * @param pctLow The low percentile to remap to 0(min) intensity
+     * @param pctHigh The high percentile to remap to 1(max) intensity
+     */
+    setPercentileThreshold(channel: number, pctLow: number, pctHigh: number): void;
+    /**
+     * Set channel opacity. This is a multiplier against all intensity values in the
+     * channel.
+     *
+     * @param channel Which channel index, 0 based.
+     * @param opacity A multiplier between 0 and 1. Default is 1
+     */
+    matOpacity(channel: number, opacity: number): void;
+    /**
+     * Set primary ray step size. This is an accuracy versus speed tradeoff.  Low
+     * values are more accurate. High values will render faster.
+     * Primary rays are the rays that are cast from the camera out into the volume.
+     *
+     * @param stepSize A value in voxels. Default is 4.  Minimum sensible value is 1.
+     */
+    setPrimaryRayStepSize(stepSize: number): void;
+    /**
+     * Set secondary ray step size. This is an accuracy versus speed tradeoff.  Low
+     * values are more accurate. High values will render faster.
+     * The secondary rays are rays which are cast toward lights after they have
+     * scattered within the volume.
+     *
+     * @param stepSize A value in voxels. Default is 4.  Minimum sensible value is 1.
+     */
+    setSecondaryRayStepSize(stepSize: number): void;
+    /**
+     * Set the background color of the rendering
+     *
+     * @param r The red value between 0 and 1
+     * @param g The green value between 0 and 1
+     * @param b The blue value between 0 and 1
+     */
+    backgroundColor(r: number, g: number, b: number): void;
+    /**
+     * Set intensity thresholds based on values around an isovalue.
+     *
+     * @param channel Which channel index, 0 based.
+     * @param isovalue The value to center at maximum intensity, between 0 and 1
+     * @param isorange A range around the isovalue to keep at constant intensity, between 0 and 1.
+     * Typically small, to select for a single isovalue.
+     */
+    setIsovalueThreshold(channel: number, isovalue: number, isorange: number): void;
+    /**
+     * Set intensity thresholds based on a piecewise linear transfer function.
+     *
+     * @param channel Which channel index, 0 based.
+     * @param data An array of values.  5 floats per control point.  first is position (0-1),
+     * next four are rgba (all 0-1).  Only alpha is currently used as the remapped
+     * intensity value.  All others are linearly interpolated.
+     */
+    setControlPoints(channel: number, data: number[]): void;
+    /**
+     * Load a time from the current volume file
+     *
+     * @param time zero-based index to select the time sample.  Defaults to 0
+     */
+    setTime(time: number): void;
+    /**
+     * Set the color for the bounding box display
+     *
+     * @param r the red value, from 0 to 1
+     * @param g the green value, from 0 to 1
+     * @param b the blue value, from 0 to 1
+     */
+    boundingBoxColor(r: number, g: number, b: number): void;
+    /**
+     * Turn bounding box display on or off
+     *
+     * @param on 0 to hide bounding box, 1 to show it
+     */
+    showBoundingBox(on: number): void;
+    /**
+     * Completely specify volume data to load
+     *
+     * @param path URL or directory or file path to the data. The path must be locally
+     * accessible from the AGAVE server.
+     * @param scene zero-based index to select the scene, for multi-scene files. Defaults to 0
+     * @param multiresolutionLevel zero-based index to select the multiresolution level.  Defaults to 0
+     * @param time zero-based index to select the time sample.  Defaults to 0
+     * @param channels zero-based indices to select the channels.  Defaults to all channels
+     * @param region 6 integers specifying the region to load.  Defaults to the entire volume.
+     * Any list length other than 0 or 6 is an error.
+     */
+    loadData(path: string, scene?: number, multiresolutionLevel?: number, time?: number, channels?: number[], region?: number[]): void;
+    /**
+     * Turn scale bar display on or off
+     *
+     * @param on 0 to hide scale bar, 1 to show it
+     */
+    showScaleBar(on: number): void;
+    flushCommandBuffer(): void;
+}

package/es/types/commandbuffer.d.ts

@@ -0,0 +1,58 @@
+type CmdArgs = string | number | number[];
+export declare const COMMANDS: {
+    SESSION: (string | number)[];
+    ASSET_PATH: (string | number)[];
+    LOAD_OME_TIF: (string | number)[];
+    EYE: (string | number)[];
+    TARGET: (string | number)[];
+    UP: (string | number)[];
+    APERTURE: (string | number)[];
+    CAMERA_PROJECTION: (string | number)[];
+    FOCALDIST: (string | number)[];
+    EXPOSURE: (string | number)[];
+    MAT_DIFFUSE: (string | number)[];
+    MAT_SPECULAR: (string | number)[];
+    MAT_EMISSIVE: (string | number)[];
+    RENDER_ITERATIONS: (string | number)[];
+    STREAM_MODE: (string | number)[];
+    REDRAW: number[];
+    SET_RESOLUTION: (string | number)[];
+    DENSITY: (string | number)[];
+    FRAME_SCENE: number[];
+    MAT_GLOSSINESS: (string | number)[];
+    ENABLE_CHANNEL: (string | number)[];
+    SET_WINDOW_LEVEL: (string | number)[];
+    ORBIT_CAMERA: (string | number)[];
+    SKYLIGHT_TOP_COLOR: (string | number)[];
+    SKYLIGHT_MIDDLE_COLOR: (string | number)[];
+    SKYLIGHT_BOTTOM_COLOR: (string | number)[];
+    LIGHT_POS: (string | number)[];
+    LIGHT_COLOR: (string | number)[];
+    LIGHT_SIZE: (string | number)[];
+    SET_CLIP_REGION: (string | number)[];
+    SET_VOXEL_SCALE: (string | number)[];
+    AUTO_THRESHOLD: (string | number)[];
+    SET_PERCENTILE_THRESHOLD: (string | number)[];
+    MAT_OPACITY: (string | number)[];
+    SET_PRIMARY_RAY_STEP_SIZE: (string | number)[];
+    SET_SECONDARY_RAY_STEP_SIZE: (string | number)[];
+    BACKGROUND_COLOR: (string | number)[];
+    SET_ISOVALUE_THRESHOLD: (string | number)[];
+    SET_CONTROL_POINTS: (string | number)[];
+    LOAD_VOLUME_FROM_FILE: (string | number)[];
+    SET_TIME: (string | number)[];
+    SET_BOUNDING_BOX_COLOR: (string | number)[];
+    SHOW_BOUNDING_BOX: (string | number)[];
+    TRACKBALL_CAMERA: (string | number)[];
+    LOAD_DATA: (string | number)[];
+    SHOW_SCALE_BAR: (string | number)[];
+};
+export declare class CommandBuffer {
+    private prebuffer;
+    private buffer;
+    constructor();
+    prebufferToBuffer(): ArrayBuffer;
+    addCommand(...args: CmdArgs[]): void;
+    length(): number;
+}
+export {};

package/es/types/index.d.ts

@@ -0,0 +1,2 @@
+import { AgaveClient } from "./agave";
+export { AgaveClient };

package/es/types/test/placeholder.test.d.ts

@@ -0,0 +1 @@
+export {};