@vertexvis/viewer 0.15.2-testing.3 → 0.15.2

package/dist/types/components/scene-tree/lib/controller.d.ts

@@ -1,6 +1,6 @@
 import { Node } from '@vertexvis/scene-tree-protos/scenetree/protos/domain_pb';
-import { GetTreeResponse } from '@vertexvis/scene-tree-protos/scenetree/protos/scene_tree_api_pb';
-import { SceneTreeAPIClient } from '@vertexvis/scene-tree-protos/scenetree/protos/scene_tree_api_pb_service';
+import { GetTreeResponse, SubscribeResponse } from '@vertexvis/scene-tree-protos/scenetree/protos/scene_tree_api_pb';
+import { ResponseStream, SceneTreeAPIClient } from '@vertexvis/scene-tree-protos/scenetree/protos/scene_tree_api_pb_service';
 import { Disposable, EventDispatcher, Listener } from '@vertexvis/utils';
 import { MetadataKey } from '../interfaces';
 import { SceneTreeErrorDetails } from './errors';
@@ -36,11 +36,16 @@ export interface ConnectingState {
   jwtProvider: JwtProvider;
   sceneViewId: string;
 }
+export interface SubscriptionStatusState {
+  attempt: number;
+  stream: ResponseStream<SubscribeResponse>;
+}
 export interface ConnectedState {
   type: 'connected';
   jwtProvider: JwtProvider;
   sceneViewId: string;
   subscription: Disposable;
+  subscriptionStatusState?: SubscriptionStatusState;
 }
 export interface ConnectionFailedState {
   type: 'failure';
@@ -48,6 +53,11 @@ export interface ConnectionFailedState {
   jwtProvider: JwtProvider;
   sceneViewId: string;
 }
+export interface ConnectionCancelledState {
+  type: 'cancelled';
+  jwtProvider?: JwtProvider;
+  sceneViewId?: string;
+}
 /**
  * A set of options to configure tree filtering behavior.
  */
@@ -66,7 +76,7 @@ export interface FilterTreeOptions {
    */
   columns?: MetadataKey[];
 }
-declare type ConnectionState = DisconnectedState | ConnectingState | ConnectedState | ConnectionFailedState;
+declare type ConnectionState = DisconnectedState | ConnectingState | ConnectedState | ConnectionFailedState | ConnectionCancelledState;
 /**
  * The `SceneTreeController` is responsible for coordinating interactions of the
  * view, fetching and mutating tree data on the server, maintaining state and
@@ -78,6 +88,7 @@ export declare class SceneTreeController {
   private connectOptions;
   private static IDLE_RECONNECT_IN_SECONDS;
   private static LOST_CONNECTION_RECONNECT_IN_SECONDS;
+  private static MAX_SUBSCRIPTION_RETRY_COUNT;
   private nextPageId;
   private pages;
   private activeRowRange;
@@ -109,6 +120,7 @@ export declare class SceneTreeController {
    */
   stateChanged(listener: Listener<SceneTreeState | undefined>): Disposable;
   setDebugLogs(debugLogs: boolean): void;
+  private handleSubscriptionHandshakeTimeout;
   connect(jwtProvider: JwtProvider): Promise<void>;
   private clearReconnectTimer;
   private clearHandshakeTimer;
@@ -117,6 +129,7 @@ export declare class SceneTreeController {
   private startReconnectTimer;
   connectToViewer(viewer: HTMLVertexViewerElement): Disposable;
   disconnect(reset?: boolean): void;
+  cancel(): void;
   /**
    * Collapses a node with the given node ID.
    *
@@ -248,11 +261,13 @@ export declare class SceneTreeController {
   private requestServerStream;
   private createJwtMetadata;
   private ifConnectionHasJwt;
+  private ifErrorIsFatal;
   private getConnectionError;
   private constrainPageRange;
   private constrainPageIndex;
   private constrainRowOffsets;
   private get maxPages();
   private log;
+  private isConnectedState;
 }
 export {};

package/dist/types/components/scene-tree/lib/errors.d.ts

@@ -1,13 +1,28 @@
+import { CustomError } from '../../../lib/errors';
 export declare enum SceneTreeErrorCode {
   UNKNOWN = 0,
   SCENE_TREE_DISABLED = 1,
   MISSING_VIEWER = 2,
   DISCONNECTED = 3,
-  SUBSCRIPTION_FAILURE = 4
+  SUBSCRIPTION_FAILURE = 4,
+  UNAUTHORIZED = 5
 }
 export declare class SceneTreeErrorDetails {
+  readonly name: keyof typeof SceneTreeErrorCode;
   readonly code: SceneTreeErrorCode;
   readonly link?: string | undefined;
   readonly message: string;
-  constructor(code: SceneTreeErrorCode, link?: string | undefined);
+  constructor(name: keyof typeof SceneTreeErrorCode, code: SceneTreeErrorCode, link?: string | undefined);
+}
+export declare class SceneTreeError extends CustomError {
+  constructor(message: string, e?: Error);
+}
+export declare class SceneTreeUnauthorizedError extends SceneTreeError {
+  constructor(message: string, e?: Error);
+}
+export declare class SceneTreeConnectionCancelledError extends SceneTreeError {
+  constructor(message: string, e?: Error);
+}
+export declare class SceneTreeOperationFailedError extends SceneTreeError {
+  constructor(message: string, e?: Error);
 }

package/dist/types/components/viewer/viewer.d.ts

@@ -264,6 +264,7 @@ export declare class Viewer {
   private resizeTimer?;
   private interactionHandlers;
   private defaultInteractionHandlerDisposables;
+  private tapHandlerDisposable?;
   private interactionApi;
   private tapKeyInteractions;
   private defaultTapKeyInteractions;
@@ -489,6 +490,7 @@ export declare class Viewer {
   private clearDefaultKeyboardInteractions;
   private initializeDefaultCameraInteractionHandlers;
   private initializeDefaultKeyboardInteractionHandlers;
+  private initializeDefaultTapInteractionHandler;
   private initializeInteractionHandler;
   private createInteractionApi;
   private handleCursorChanged;

package/dist/types/components/viewer-box-query-tool/viewer-box-query-tool.d.ts

@@ -0,0 +1,94 @@
+import { h } from '../../stencil-public-runtime';
+import { VolumeIntersectionQueryController } from '../../lib/volume-intersection/controller';
+import { VolumeIntersectionQueryModel } from '../../lib/volume-intersection/model';
+export declare type VolumeIntersectionQueryType = 'clearAndSelect' | 'select' | 'deselect';
+export declare type VolumeIntersectionQueryMode = 'exclusive' | 'inclusive';
+/**
+ * The `ViewerBoxQueryTool` allows for the drawing of a "box" on screen to represent
+ * a query for items in a specific area of the viewer. This tool then allows for an
+ * operation to be performed on the items contained (exclusive) by the box or both
+ * contained by and intersecting with (inclusive) the box.
+ */
+export declare class ViewerBoxQueryTool {
+  /**
+   * The viewer that this component is bound to. This is automatically assigned
+   * if added to the light-dom of a parent viewer element.
+   */
+  viewer?: HTMLVertexViewerElement;
+  /**
+   * The controller that is responsible for performing operations using the
+   * volume intersection query defined by the drawn box and updating the model.
+   */
+  controller?: VolumeIntersectionQueryController;
+  /**
+   * The model that contains the points representing the corners of the box
+   * displayed on screen, the type of the query to be performed, and methods
+   * for setting these values.
+   */
+  model?: VolumeIntersectionQueryModel;
+  /**
+   * The default operation to perform when a drag has completed and the intersection
+   * query will be run. Defaults to `clearAndSelect`, and can be changed to `select` or `deselect`.
+   *
+   * `clearAndSelect` will clear all existing selection, and select the results of the query.
+   * `select` will maintain existing selection, and select the results of the query.
+   * `deselect` will maintain existing selection, and deselect the results of the query.
+   *
+   * The operation behavior for this intersection query tool can also be changed by
+   * providing a custom implementation of the `VolumeIntersectionQueryController`, or
+   * by using the `setOperationTransform` method of the default controller.
+   */
+  operationType: VolumeIntersectionQueryType;
+  /**
+   * An optional value to specify a singular mode of intersection query. This value
+   * defaults to `undefined`, which will indicate that both `exclusive` and `inclusive`
+   * queries should be made, with `inclusive` being represented by a left to right
+   * drag behavior and `exclusive` being represented by a right to left drag.
+   *
+   * Setting this value to `inclusive` will cause dragging left to right and left to right
+   * to result in an `inclusive` query, and the box will only be styled for `inclusive` queries.
+   *
+   * Setting this value to `exclusive` will cause dragging left to right and left to right
+   * to result in an `exclusive` query, and the box will only be styled for `exclusive` queries.
+   */
+  mode?: VolumeIntersectionQueryMode;
+  private details?;
+  private hostEl;
+  private interactionHandler?;
+  private interactionHandlerDisposable?;
+  private operationStartedDisposable?;
+  private operationCompleteDisposable?;
+  private screenBoundsChangedDisposable?;
+  constructor();
+  componentWillLoad(): void;
+  disconnectedCallback(): void;
+  /**
+   * @ignore
+   */
+  protected handleViewerChanged(newViewer?: HTMLVertexViewerElement): void;
+  /**
+   * @ignore
+   */
+  protected handleDefaultOperationChange(updatedOperationType: VolumeIntersectionQueryType): void;
+  /**
+   * @ignore
+   */
+  protected handleModeChange(updatedMode?: VolumeIntersectionQueryMode): void;
+  /**
+   * @ignore
+   */
+  protected handleControllerChange(controller?: VolumeIntersectionQueryController): void;
+  /**
+   * @ignore
+   */
+  protected render(): h.JSX.IntrinsicElements;
+  private handleScreenBoundsChanged;
+  private handleExecuteStarted;
+  private handleExecuteComplete;
+  private registerInteractionHandler;
+  private deregisterInteractionHandler;
+  private updateTypeAttribute;
+  private setDefaultClearAndSelectOperation;
+  private setDefaultSelectOperation;
+  private setDefaultDeselectOperation;
+}

package/dist/types/components/viewer-pin-tool/utils.d.ts

@@ -8,4 +8,4 @@ export declare function translatePointToScreen(pt: Point.Point, canvasDimensions
 /**
  * Translates a point in screen units to a point in relative units.
  */
-export declare function translatePointToRelative(pt: Point.Point, canvasDimensions: Dimensions.Dimensions): Point.Point;
+export declare function translatePointToRelative(pt: Point.Point, canvasDimensions: Dimensions.Dimensions, includeOffset?: boolean, xOffset?: number, yOffset?: number): Point.Point;

package/dist/types/components.d.ts

@@ -33,6 +33,9 @@ import { KeyInteraction } from "./lib/interactions/keyInteraction";
 import { Cursor } from "./lib/cursors";
 import { BaseInteractionHandler } from "./lib/interactions/baseInteractionHandler";
 import { Scene } from "./lib/scenes/scene";
+import { VolumeIntersectionQueryController } from "./lib/volume-intersection/controller";
+import { VolumeIntersectionQueryModel } from "./lib/volume-intersection/model";
+import { VolumeIntersectionQueryMode, VolumeIntersectionQueryType } from "./components/viewer-box-query-tool/viewer-box-query-tool";
 import { ViewerToolbarPlacement } from "./components/viewer-toolbar/viewer-toolbar";
 import { ViewerToolbarGroupDirection } from "./components/viewer-toolbar-group/viewer-toolbar-group";
 import { ViewerDomRendererDrawMode } from "./components/viewer-dom-renderer/viewer-dom-renderer";
@@ -464,6 +467,28 @@ export namespace Components {
          */
         "viewport": Viewport;
     }
+    interface VertexViewerBoxQueryTool {
+        /**
+          * The controller that is responsible for performing operations using the volume intersection query defined by the drawn box and updating the model.
+         */
+        "controller"?: VolumeIntersectionQueryController;
+        /**
+          * An optional value to specify a singular mode of intersection query. This value defaults to `undefined`, which will indicate that both `exclusive` and `inclusive` queries should be made, with `inclusive` being represented by a left to right drag behavior and `exclusive` being represented by a right to left drag.  Setting this value to `inclusive` will cause dragging left to right and left to right to result in an `inclusive` query, and the box will only be styled for `inclusive` queries.  Setting this value to `exclusive` will cause dragging left to right and left to right to result in an `exclusive` query, and the box will only be styled for `exclusive` queries.
+         */
+        "mode"?: VolumeIntersectionQueryMode;
+        /**
+          * The model that contains the points representing the corners of the box displayed on screen, the type of the query to be performed, and methods for setting these values.
+         */
+        "model"?: VolumeIntersectionQueryModel;
+        /**
+          * The default operation to perform when a drag has completed and the intersection query will be run. Defaults to `clearAndSelect`, and can be changed to `select` or `deselect`.  `clearAndSelect` will clear all existing selection, and select the results of the query. `select` will maintain existing selection, and select the results of the query. `deselect` will maintain existing selection, and deselect the results of the query.  The operation behavior for this intersection query tool can also be changed by providing a custom implementation of the `VolumeIntersectionQueryController`, or by using the `setOperationTransform` method of the default controller.
+         */
+        "operationType": VolumeIntersectionQueryType;
+        /**
+          * The viewer that this component is bound to. This is automatically assigned if added to the light-dom of a parent viewer element.
+         */
+        "viewer"?: HTMLVertexViewerElement;
+    }
     interface VertexViewerButton {
     }
     interface VertexViewerDefaultToolbar {
@@ -1244,6 +1269,12 @@ declare global {
         prototype: HTMLVertexViewerElement;
         new (): HTMLVertexViewerElement;
     };
+    interface HTMLVertexViewerBoxQueryToolElement extends Components.VertexViewerBoxQueryTool, HTMLStencilElement {
+    }
+    var HTMLVertexViewerBoxQueryToolElement: {
+        prototype: HTMLVertexViewerBoxQueryToolElement;
+        new (): HTMLVertexViewerBoxQueryToolElement;
+    };
     interface HTMLVertexViewerButtonElement extends Components.VertexViewerButton, HTMLStencilElement {
     }
     var HTMLVertexViewerButtonElement: {
@@ -1411,6 +1442,7 @@ declare global {
         "vertex-scene-tree-toolbar": HTMLVertexSceneTreeToolbarElement;
         "vertex-scene-tree-toolbar-group": HTMLVertexSceneTreeToolbarGroupElement;
         "vertex-viewer": HTMLVertexViewerElement;
+        "vertex-viewer-box-query-tool": HTMLVertexViewerBoxQueryToolElement;
         "vertex-viewer-button": HTMLVertexViewerButtonElement;
         "vertex-viewer-default-toolbar": HTMLVertexViewerDefaultToolbarElement;
         "vertex-viewer-dom-element": HTMLVertexViewerDomElementElement;
@@ -1724,6 +1756,28 @@ declare namespace LocalJSX {
          */
         "viewport"?: Viewport;
     }
+    interface VertexViewerBoxQueryTool {
+        /**
+          * The controller that is responsible for performing operations using the volume intersection query defined by the drawn box and updating the model.
+         */
+        "controller"?: VolumeIntersectionQueryController;
+        /**
+          * An optional value to specify a singular mode of intersection query. This value defaults to `undefined`, which will indicate that both `exclusive` and `inclusive` queries should be made, with `inclusive` being represented by a left to right drag behavior and `exclusive` being represented by a right to left drag.  Setting this value to `inclusive` will cause dragging left to right and left to right to result in an `inclusive` query, and the box will only be styled for `inclusive` queries.  Setting this value to `exclusive` will cause dragging left to right and left to right to result in an `exclusive` query, and the box will only be styled for `exclusive` queries.
+         */
+        "mode"?: VolumeIntersectionQueryMode;
+        /**
+          * The model that contains the points representing the corners of the box displayed on screen, the type of the query to be performed, and methods for setting these values.
+         */
+        "model"?: VolumeIntersectionQueryModel;
+        /**
+          * The default operation to perform when a drag has completed and the intersection query will be run. Defaults to `clearAndSelect`, and can be changed to `select` or `deselect`.  `clearAndSelect` will clear all existing selection, and select the results of the query. `select` will maintain existing selection, and select the results of the query. `deselect` will maintain existing selection, and deselect the results of the query.  The operation behavior for this intersection query tool can also be changed by providing a custom implementation of the `VolumeIntersectionQueryController`, or by using the `setOperationTransform` method of the default controller.
+         */
+        "operationType"?: VolumeIntersectionQueryType;
+        /**
+          * The viewer that this component is bound to. This is automatically assigned if added to the light-dom of a parent viewer element.
+         */
+        "viewer"?: HTMLVertexViewerElement;
+    }
     interface VertexViewerButton {
     }
     interface VertexViewerDefaultToolbar {
@@ -2440,6 +2494,7 @@ declare namespace LocalJSX {
         "vertex-scene-tree-toolbar": VertexSceneTreeToolbar;
         "vertex-scene-tree-toolbar-group": VertexSceneTreeToolbarGroup;
         "vertex-viewer": VertexViewer;
+        "vertex-viewer-box-query-tool": VertexViewerBoxQueryTool;
         "vertex-viewer-button": VertexViewerButton;
         "vertex-viewer-default-toolbar": VertexViewerDefaultToolbar;
         "vertex-viewer-dom-element": VertexViewerDomElement;
@@ -2482,6 +2537,7 @@ declare module "@stencil/core" {
             "vertex-scene-tree-toolbar": LocalJSX.VertexSceneTreeToolbar & JSXBase.HTMLAttributes<HTMLVertexSceneTreeToolbarElement>;
             "vertex-scene-tree-toolbar-group": LocalJSX.VertexSceneTreeToolbarGroup & JSXBase.HTMLAttributes<HTMLVertexSceneTreeToolbarGroupElement>;
             "vertex-viewer": LocalJSX.VertexViewer & JSXBase.HTMLAttributes<HTMLVertexViewerElement>;
+            "vertex-viewer-box-query-tool": LocalJSX.VertexViewerBoxQueryTool & JSXBase.HTMLAttributes<HTMLVertexViewerBoxQueryToolElement>;
             "vertex-viewer-button": LocalJSX.VertexViewerButton & JSXBase.HTMLAttributes<HTMLVertexViewerButtonElement>;
             "vertex-viewer-default-toolbar": LocalJSX.VertexViewerDefaultToolbar & JSXBase.HTMLAttributes<HTMLVertexViewerDefaultToolbarElement>;
             "vertex-viewer-dom-element": LocalJSX.VertexViewerDomElement & JSXBase.HTMLAttributes<HTMLVertexViewerDomElementElement>;

package/dist/types/lib/cursors.d.ts

@@ -90,3 +90,8 @@ export declare const labelPinCursor: {
   offsetX: number;
   offsetY: number;
 };
+export declare const boxQueryCursor: {
+  url: string;
+  offsetX: number;
+  offsetY: number;
+};

package/dist/types/lib/interactions/baseInteractionHandler.d.ts

@@ -24,6 +24,7 @@ export declare abstract class BaseInteractionHandler implements InteractionHandl
   private primaryInteraction;
   private currentInteraction?;
   private draggingInteraction;
+  private lastPrimaryRotateInteraction?;
   private isDragging;
   private lastMoveEvent?;
   private interactionTimer?;

package/dist/types/lib/interactions/mouseInteractions.d.ts

@@ -53,7 +53,8 @@ export declare class PanInteraction extends MouseInteraction {
 }
 export declare class TwistInteraction extends MouseInteraction {
   type: InteractionType;
-  beginDrag(event: MouseEvent, canvasPosition: Point.Point, api: InteractionApi): void;
+  private canvasRect?;
+  beginDrag(event: MouseEvent, canvasPosition: Point.Point, api: InteractionApi, element: HTMLElement): void;
   drag(event: MouseEvent, api: InteractionApi): void;
   endDrag(event: MouseEvent, api: InteractionApi): void;
 }

package/dist/types/lib/pins/interactions.d.ts

@@ -7,16 +7,18 @@ export declare class PinsInteractionHandler implements InteractionHandler {
   private element?;
   private api?;
   private cursor?;
+  private xOffset?;
+  private yOffset?;
   private rectObserver;
   private droppableSurfaces;
   private get elementRect();
-  constructor(controller: PinController);
+  constructor(controller: PinController, xOffset: number, yOffset: number);
   initialize(element: HTMLElement, api: InteractionApi): void;
   dispose(): void;
   getWorldPositionForPoint(pt: Point.Point): Promise<Vector3.Vector3 | undefined>;
   handlePlacePin(pt: Point.Point, existingPin?: Pin): Promise<void>;
   private handlePointerMove;
-  private getCusorType;
+  private getCursorType;
   private handleDrag;
   private handlePointerDown;
   private handlePointerUp;

package/dist/types/lib/pins/model.d.ts

@@ -54,7 +54,7 @@ export declare class PinModel {
    * @param pin A pin entity to draw.
    * @returns `true` if the entity has been added.
    */
-  addPin(pin: Pin, surpressEvent?: boolean): boolean;
+  addPin(pin: Pin, suppressEvent?: boolean): boolean;
   /**
    * Clears all registered entities from the model.
    */

package/dist/types/lib/scenes/camera.d.ts

@@ -146,7 +146,7 @@ export declare class PerspectiveCamera extends Camera implements FrameCamera.Per
   moveBy(delta: Vector3.Vector3): Camera;
   rotateAroundAxisAtPoint(angleInRadians: number, point: Vector3.Vector3, axis: Vector3.Vector3): Camera;
   fitToBoundingBox(boundingBox: BoundingBox.BoundingBox): Camera;
-  update(camera: Partial<FrameCamera.FrameCamera>): Camera;
+  update(camera: Partial<FrameCamera.PerspectiveFrameCamera>): Camera;
   toFrameCamera(): FramePerspectiveCamera;
   get viewVector(): Vector3.Vector3;
   /**

package/dist/types/lib/scenes/mapper.d.ts

@@ -1,11 +1,15 @@
 import { vertexvis } from '@vertexvis/frame-streaming-protos';
 import { Dimensions } from '@vertexvis/geometry';
 import { UUID } from '@vertexvis/utils';
-import { Animation, FlyTo } from '../types';
+import { Animation, FlyTo, SceneViewStateIdentifier } from '../types';
 import { ItemOperation } from './operations';
 import { QueryExpression } from './queries';
+import { SceneViewStateFeature } from './scene';
 export interface BuildSceneOperationContext {
   dimensions: Dimensions.Dimensions;
 }
+export declare function buildSceneViewStateIdentifier(identifier: UUID.UUID | SceneViewStateIdentifier.SceneViewStateIdentifier): Pick<vertexvis.protobuf.stream.ILoadSceneViewStatePayload, 'sceneViewStateId'> | Pick<vertexvis.protobuf.stream.ILoadSceneViewStatePayload, 'sceneViewStateSuppliedId'>;
+export declare function buildQueryExpression(query: QueryExpression, context: BuildSceneOperationContext): vertexvis.protobuf.stream.IQueryExpression;
 export declare function buildSceneOperation(query: QueryExpression, operations: ItemOperation[], context: BuildSceneOperationContext): vertexvis.protobuf.stream.ISceneOperation;
 export declare function buildFlyToOperation(frameCorrelationId: UUID.UUID, options: FlyTo.FlyToOptions, animation?: Animation.Animation): vertexvis.protobuf.stream.IFlyToPayload;
+export declare function toPbSceneViewStateFeatures(features: SceneViewStateFeature[]): vertexvis.protobuf.stream.SceneViewStateFeature[];

package/dist/types/lib/scenes/queries.d.ts

@@ -1,4 +1,4 @@
-import { Point } from '@vertexvis/geometry';
+import { Point, Rectangle } from '@vertexvis/geometry';
 import { ColorMaterial } from './colorMaterial';
 import { SceneItemOperationsBuilder } from './scene';
 interface AllQueryExpression {
@@ -24,6 +24,10 @@ interface SceneTreeRangeQueryExpression {
   type: 'scene-tree-range';
   range: SceneTreeRange;
 }
+interface NotQueryExpression {
+  type: 'not';
+  query: QueryExpression;
+}
 interface MetadataQueryExpression {
   type: 'metadata';
   filter: string;
@@ -37,16 +41,24 @@ interface PointQueryExpression {
   type: 'point';
   point: Point.Point;
 }
+interface VolumeIntersectionQueryExpression {
+  type: 'volume-intersection';
+  rectangle: Rectangle.Rectangle;
+  exclusive: boolean;
+}
 /**
  * Represents the sum of all possible types of expressions.
  */
-export declare type QueryExpression = AllQueryExpression | ItemQueryExpression | AndExpression | OrExpression | SceneTreeRangeQueryExpression | PointQueryExpression | MetadataQueryExpression | AllSelectedQueryExpression;
+export declare type QueryExpression = AllQueryExpression | ItemQueryExpression | AndExpression | OrExpression | SceneTreeRangeQueryExpression | PointQueryExpression | VolumeIntersectionQueryExpression | MetadataQueryExpression | AllSelectedQueryExpression | NotQueryExpression;
 /**
  * An interface that represents a query is "complete" and can be turned into an
  * expression.
  */
-interface TerminalQuery {
+declare abstract class TerminalQuery {
+  protected inverted: boolean;
+  constructor(inverted: boolean);
   build(): QueryExpression;
+  abstract queryExpressionBuilder(): QueryExpression;
 }
 interface ItemQuery<N> {
   withItemId(id: string): N;
@@ -57,7 +69,10 @@ interface BooleanQuery {
   or(): OrQuery;
 }
 export declare class RootQuery implements ItemQuery<SingleQuery> {
+  private inverted;
+  constructor(inverted?: boolean);
   all(): AllQuery;
+  not(): RootQuery;
   withItemIds(ids: string[]): BulkQuery;
   withSuppliedIds(ids: string[]): BulkQuery;
   withItemId(id: string): SingleQuery;
@@ -66,55 +81,67 @@ export declare class RootQuery implements ItemQuery<SingleQuery> {
   withMetadata(filter: string, keys: string[], exactMatch: boolean): MetadataQuery;
   withSelected(): AllSelectedQuery;
   withPoint(point: Point.Point): PointQuery;
+  withVolumeIntersection(rectangle: Rectangle.Rectangle, exclusive?: boolean): VolumeIntersectionQuery;
 }
-export declare class AllQuery implements TerminalQuery {
-  build(): QueryExpression;
+export declare class NotQuery extends RootQuery {
+  constructor(inverted: boolean);
 }
-export declare class SceneTreeRangeQuery implements TerminalQuery {
+export declare class AllQuery extends TerminalQuery {
+  constructor(inverted?: boolean);
+  queryExpressionBuilder(): QueryExpression;
+}
+export declare class SceneTreeRangeQuery extends TerminalQuery {
   private range;
-  constructor(range: SceneTreeRange);
-  build(): SceneTreeRangeQueryExpression;
+  constructor(range: SceneTreeRange, inverted: boolean);
+  queryExpressionBuilder(): SceneTreeRangeQueryExpression;
 }
-export declare class MetadataQuery implements TerminalQuery {
+export declare class MetadataQuery extends TerminalQuery {
   private filter;
   private keys;
   private exactMatch;
-  constructor(filter: string, keys: string[], exactMatch: boolean);
-  build(): MetadataQueryExpression;
+  constructor(filter: string, keys: string[], exactMatch: boolean, inverted: boolean);
+  queryExpressionBuilder(): MetadataQueryExpression;
 }
-export declare class AllSelectedQuery implements TerminalQuery {
-  build(): AllSelectedQueryExpression;
+export declare class AllSelectedQuery extends TerminalQuery {
+  constructor(inverted: boolean);
+  queryExpressionBuilder(): AllSelectedQueryExpression;
 }
-export declare class PointQuery implements TerminalQuery {
+export declare class PointQuery extends TerminalQuery {
   private point;
-  constructor(point: Point.Point);
-  build(): PointQueryExpression;
+  constructor(point: Point.Point, inverted: boolean);
+  queryExpressionBuilder(): PointQueryExpression;
+}
+export declare class VolumeIntersectionQuery extends TerminalQuery {
+  private rectangle;
+  private exclusive?;
+  constructor(rectangle: Rectangle.Rectangle, inverted: boolean, exclusive?: boolean | undefined);
+  queryExpressionBuilder(): VolumeIntersectionQueryExpression;
 }
-export declare class BulkQuery implements TerminalQuery {
+export declare class BulkQuery extends TerminalQuery {
   private ids;
   private type;
-  constructor(ids: string[], type: 'item-id' | 'supplied-id');
-  build(): QueryExpression;
+  constructor(ids: string[], type: 'item-id' | 'supplied-id', inverted: boolean);
+  queryExpressionBuilder(): QueryExpression;
 }
-declare class SingleQuery implements TerminalQuery, BooleanQuery {
+declare class SingleQuery extends TerminalQuery implements BooleanQuery {
   private query;
-  constructor(query: QueryExpression);
-  build(): QueryExpression;
+  constructor(query: QueryExpression, inverted: boolean);
+  queryExpressionBuilder(): QueryExpression;
   and(): AndQuery;
   or(): OrQuery;
 }
-export declare class OrQuery implements TerminalQuery, ItemQuery<OrQuery> {
+export declare class OrQuery extends TerminalQuery implements ItemQuery<OrQuery> {
   private expressions;
-  constructor(expressions: QueryExpression[]);
-  build(): QueryExpression;
+  constructor(expressions: QueryExpression[], inverted: boolean);
+  queryExpressionBuilder(): QueryExpression;
   withItemId(id: string): OrQuery;
   withSuppliedId(id: string): OrQuery;
   or(): OrQuery;
 }
-export declare class AndQuery implements TerminalQuery, ItemQuery<AndQuery> {
+export declare class AndQuery extends TerminalQuery implements ItemQuery<AndQuery> {
   private expressions;
-  constructor(expressions: QueryExpression[]);
-  build(): QueryExpression;
+  constructor(expressions: QueryExpression[], inverted: boolean);
+  queryExpressionBuilder(): QueryExpression;
   withItemId(id: string): AndQuery;
   withSuppliedId(id: string): AndQuery;
   and(): AndQuery;

package/dist/types/lib/scenes/scene.d.ts

@@ -3,6 +3,7 @@ import { BoundingBox, Dimensions, Point } from '@vertexvis/geometry';
 import { StreamApi } from '@vertexvis/stream-api';
 import { UUID } from '@vertexvis/utils';
 import { FrameDecoder } from '../mappers';
+import { SceneViewStateIdentifier } from '../types';
 import { Frame } from '../types/frame';
 import { Camera } from '.';
 import { ColorMaterial } from './colorMaterial';
@@ -51,6 +52,10 @@ export declare class ItemsOperationExecutor {
 }
 export declare type TerminalItemOperationBuilder = SceneItemOperationsBuilder | SceneItemOperationsBuilder[];
 export declare type ImageScaleProvider = () => Point.Point | undefined;
+/**
+ * The features of a scene view state that can be applied to the current scene
+ */
+export declare type SceneViewStateFeature = 'camera' | 'cross_section' | 'material_overrides' | 'selection' | 'transforms' | 'visibility';
 /**
  * A class that represents the `Scene` that has been loaded into the viewer. On
  * it, you can retrieve attributes of the scene, such as the camera. It also
@@ -70,7 +75,11 @@ export declare class Scene {
   /**
    * Applies the provided scene view state to the scene.
    */
-  applySceneViewState(sceneViewStateId: UUID.UUID, opts?: SceneExecutionOptions): Promise<vertexvis.protobuf.stream.ILoadSceneViewStateResult | undefined>;
+  applySceneViewState(sceneViewStateId: UUID.UUID | SceneViewStateIdentifier.SceneViewStateIdentifier, opts?: SceneExecutionOptions): Promise<vertexvis.protobuf.stream.ILoadSceneViewStateResult | undefined>;
+  /**
+   * Applies the specified features of the provided scene view state to the scene.
+   */
+  applyPartialSceneViewState(sceneViewStateId: UUID.UUID | SceneViewStateIdentifier.SceneViewStateIdentifier, featuresToApply: SceneViewStateFeature[], opts?: SceneExecutionOptions): Promise<vertexvis.protobuf.stream.ILoadSceneViewStateResult | undefined>;
   /**
    * Resets the view to its default state, with the ability to reset the camera to that of the base scene.
    */

package/dist/types/lib/types/frame.d.ts

@@ -129,7 +129,7 @@ export declare class FramePerspectiveCamera extends FrameCameraBase implements F
   readonly far: number;
   readonly aspectRatio: number;
   readonly fovY: number;
-  constructor(position: Vector3.Vector3, lookAt: Vector3.Vector3, up: Vector3.Vector3, near: number, far: number, aspectRatio: number, fovY?: number);
+  constructor(position: Vector3.Vector3, lookAt: Vector3.Vector3, up: Vector3.Vector3, near: number, far: number, aspectRatio: number, fovY: number);
   /**
    * Converts this `FramePerspectiveCamera` to a `FrameOrthographicCamera` using
    * the provided `boundingBox` to compute the viewing frustum.

package/dist/types/lib/types/index.d.ts

@@ -10,6 +10,7 @@ import * as FlyTo from './flyToOptions';
 import * as FrameCamera from './frameCamera';
 import * as Interactions from './interactions';
 import * as LoadableResource from './loadableResource';
+import * as SceneViewStateIdentifier from './sceneViewStateIdentifier';
 export * from './depthBuffer';
 export * from './entities';
 export * from './featureMap';
@@ -22,4 +23,4 @@ export * from './stencilBuffer';
 export * from './synchronizedClock';
 export * from './typeGuards';
 export * from './viewport';
-export { Animation, ClippingPlanes, CrossSectioning, Events, Flags, FlyTo, FrameCamera, Interactions, LoadableResource, };
+export { Animation, ClippingPlanes, CrossSectioning, Events, Flags, FlyTo, FrameCamera, Interactions, LoadableResource, SceneViewStateIdentifier, };

package/dist/types/lib/types/loadableResource.d.ts

@@ -5,12 +5,18 @@ interface StreamKeyResource {
 export declare type LoadableResource = StreamKeyResource;
 export interface Resource {
   resource: LoadableResource;
-  queries: QueryResource[];
+  subResource?: PathResource;
+  queries: QueryValue[];
 }
 export declare function fromUrn(urn: string): Resource;
 export interface SceneViewStateResource {
   type: 'scene-view-state';
+  id?: string;
+}
+export declare type PathResource = SceneViewStateResource;
+export interface SuppliedIdQueryValue {
+  type: 'supplied-id';
   id: string;
 }
-export declare type QueryResource = SceneViewStateResource;
+export declare type QueryValue = SceneViewStateResource | SuppliedIdQueryValue;
 export {};