Extension SDK API reference

HostApi

const hostApi = createHostConnection()

getElements

getElements({
    select?: ElementSelect,
    where?: ElementFilter
}): Promise<QueryPick<ElementData, ElementSelect>[]>

Filter by ElementFilter and select the returned properties with ElementSelect which defaults to DefaultSelect`

Return type matches ElementSelect

getElementById

getElementById({
    id: string,
    select?: ElementSelect
}): Promise<QueryPick<ElementData, ElementSelect>>

Return type matches ElementSelect

getSpaces

getSpaces({
    select?: SpaceSelect,
    where?: SpaceFilter
}): Promise<QueryPick<SpaceData, SpaceSelect>[]>

Filter by SpaceFilter and select the returned properties with SpaceSelect which defaults to DefaultSelect

Return type matches SpaceSelect

getSpaceById

getSpaceById({
    id: string,
    select?: SpaceSelect
}): Promise<QueryPick<SpaceData, SpaceSelect>>

Return type matches SpaceSelect

getLayout

getLayout({
    select?: BaseSelect
}): Promise<QueryPick<BaseData, BaseSelect>>

Return type matches BaseSelect

getFloor

getFloor({
    select?: FloorSelect
}): Promise<QueryPick<FloorData, FloorSelect>>

Returns metadata about the current floor. Defaults to FloorDefaultSelect.

addPlanGraphic

addPlanGraphic({
    shapes: Shape[],
    interaction?: { click?: boolean; drag?: boolean },
    position?: Vector2,
    fixedScreenSize?: boolean,
    id?: string,
    layerId?: string,
    clearLayer?: boolean
}): Promise<{ id: string }>

getPath

Compute walking path between two points

getPath({
    start: Vector2,
    end: Vector2
}): Promise<{ path: Vector2[], distance: number }>

findClosest

Find the closest entity by ElementFilter or SpaceFilter

findClosest({
    start: Vector2,
    where: ElementFilter | SpaceFilter
}): Promise<{
  path: Vector2[],
  distance: number,
  target: { id: string } | null
}>

Types

DefaultSelect

type DefaultSelect = { id: true; type: true }

BaseSelect

interface BaseSelect {
  id?: boolean
  type?: boolean
  name?: boolean
  customId?: boolean
  customAttributes?: boolean | Record<string, boolean>
  dimensions?:
    | boolean
    | {
        width?: boolean
        length?: boolean
        height?: boolean
      }
  labelPoint?: boolean
  contour?: boolean
  boundingBox?: boolean
  boundingBoxContour?: boolean
}

BaseData

Properties shared by all queryable entities. boundingBox and dimensions are in meters, with y as the up axis.

interface BaseData {
  id: string
  name: string
  type: string
  customId: string
  customAttributes: Record<string, string | number | boolean | null>
  /** dimensions in meters */
  dimensions: { width: number; length: number; height: number }
  /** axis aligned bounding box in root space */
  boundingBox: { min: Vector3; max: Vector3 }
  /** contour of the object aligned bounding box in root space */
  boundingBoxContour: Vector2[]
  labelPoint: Vector2
  contour: Vector2[][]
}

SpaceSelect

export interface SpaceSelect extends BaseSelect {
  category?: boolean
  subCategory?: boolean
  isExternal?: boolean
  area?: boolean
  seatCapacity?: boolean
  elements?: ElementQuery
}

SpaceData

interface SpaceData extends BaseData {
  type: 'space'
  isExternal: boolean
  category: string
  subCategory: string
  seatCapacity: number
  area: number
  elements: ElementData[]
  boundaries: {
    profile: Vector2[]
    segments: {
      points: [Vector2, Vector2]
      element: { id: string; type: string } | null
      adjacentSpaceId: string | null
    }[]
  }[]
}

ElementSelect

export interface ElementSelect extends BaseSelect {
  product?: ProductSelect | boolean
  isExternal?: boolean
  transform?: boolean
  localTransform?: boolean
  localBoundingBox?: boolean
}

ElementData

interface ElementData extends BaseData {
  type: string
  isExternal: boolean
  category: string
  subCategory: string
  product: ProductData
  /** transform in root space */
  transform: { position: Vector3; rotation: number }
  /** local transform for nested elements like openings, windows */
  localTransform: { position: Vector3; rotation: number }
  /** local object aligned bounding box */
  localBoundingBox: { min: Vector3; max: Vector3 }
  elements: ElementData[]
  parent: ElementData
}

ProductData

interface ProductData extends BaseData {
  type: 'product'
  category: string
  subCategory: string
  seatCapacity: number
}

LayoutData

interface LayoutData extends BaseData {
  type: 'layout'
}

FloorData

type FloorData = {
  id: string
  name: string
  level: string
  area: number
  labels: { name: string; color: string }[]
  transform: { position: Vector3; rotation: number }
  location: {
    address: {
      line1?: string
      line2?: string
      city?: string
      state?: string
      postalCode?: string
      country?: string
    }
    coordinates: { lat: number; long: number; bearing: number }
  }
}

FloorDefaultSelect

type FloorDefaultSelect = {
  id: true
  name: true
  area: true
  level: true
  labels: true
  transform: true
  location: true
}

FloorSelect

interface FloorSelect {
  id?: boolean
  name?: boolean
  level?: boolean
  area?: boolean
  createdAt?: boolean
  updatedAt?: boolean
  isPrivate?: boolean
  isArchived?: boolean
  labels?: boolean | { name?: boolean; color?: boolean }
  transform?: boolean | { position?: boolean; rotation?: boolean }
  location?: boolean | { address?: boolean; coordinates?: boolean }
}

BaseFilter

interface BaseFilter {
  id?: StringComparator
  type?: StringComparator
  name?: StringComparator
  customId?: StringComparator
  customAttributes?: Record<
    string,
    StringComparator | NumberComparator | BooleanComparator | NullComparator
  >
  dimensions?: {
    width?: NumberComparator
    length?: NumberComparator
    height?: NumberComparator
  }
}

ElementFilter

Type

export interface ElementFilter extends BaseFilter {
  /** for assets inherited from product */
  category?: StringComparator
  /** for assets inherited from product */
  subCategory?: StringComparator
  /** find elements at specific location */
  at?: Vector2
  /** find elements within rectangle */
  within?: { min: Vector2; max: Vector2 }
  isExternal?: BooleanComparator
  product?: ProductFilter
}

Example

Using StringComparator

{
  where: {
    subCategory: 'workstation'
  }
}

Using NullComparator

// return all entities that have a value set for the custom attribute 'employee-id'
{
  where: { customAttributes: { 'employee-id': { null: false }} }
}

SpaceFilter

Type

export interface SpaceFilter extends BaseFilter {
  category?: StringComparator
  subCategory?: StringComparator
  seatCapacity?: NumberComparator
  /** find spaces at specific location */
  at?: Vector2
  /** find spaces within rectangle */
  within?: { min: Vector2; max: Vector2 }
  isExternal?: BooleanComparator
  area?: NumberComparator
}

Example

Using NumberComparator

{
  where: { area: { gte: 50 }, seatCapacity: { gte: 12 } }
}

Using BooleanComparator

{
  where: {
    isExternal: true
  }
}

SpaceQuery

export type SpaceQuery = {
  select?: SpaceSelect
  where?: SpaceFilter
}

StringComparator

export type StringComparator =
  | string
  | { eq: string }
  | { neq: string }
  | { in: string[] }
  | { nin: string[] }
  /** case-insensitive partial match */
  | { contains: string }

NumberComparator

export type NumberComparator =
  | number
  | { eq: number }
  | { neq: number }
  | { in: number[] }
  | { nin: number[] }
  | { gt: number }
  | { gte: number }
  | { lt: number }
  | { lte: number }

BooleanComparator

export type BooleanComparator = boolean | { eq: boolean } | { neq: boolean }

NullComparator

Can be used to return entities depending on whether the field has a value or not

export type NullComparator = { null: boolean }