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

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
}

SpaceSelect

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

ElementSelect

export interface ElementSelect extends BaseSelect {
  product?: ProductSelect | boolean
  isExternal?: boolean
  transform?: boolean
  localTransform?: boolean
  localBoundingBox?: 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 }