FenixEdu™

acad_revolution

acad_revolution(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, profile::Shape, p, n, start_angle, amplitude, mat)

acw_vertices

```
acw_vertices(vs)
```

add_current_backend

```
add_current_backend(b::Backend)
```

add_cyl

add_cyl(p::Loc, rho::Real, phi::Real, z::Real)

add_door

```
add_door()
```
```
add_door(w::Wall)
```
```
add_door(w::Wall, loc::Loc)
```

add_door(w::Wall, loc::Loc, family::DoorFamily)

add_pol

```
add_pol(p::Loc, rho::Real, phi::Real)
```

add_sph

add_sph(p::Loc, rho::Real, phi::Real, psi::Real)

add_window

```
add_window()
```
```
add_window(w::Wall)
```
```
add_window(w::Wall, loc::Loc)
```

add_window(w::Wall, loc::Loc, family::WindowFamily)

add_x

```
add_x(p::Loc, x::Real)
```

add_xy

```
add_xy(p::Loc, x::Real, y::Real)
```

add_xyz

add_xyz(p::Loc, x::Real, y::Real, z::Real)

add_xz

```
add_xz(p::Loc, x::Real, z::Real)
```

add_y

```
add_y(p::Loc, y::Real)
```

add_yz

```
add_yz(p::Loc, y::Real, z::Real)
```

add_z

```
add_z(p::Loc, z::Real)
```

after_connecting

after_connecting(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64})

```
after_connecting(b::RemoteBackend)
```

all_levels

```
all_levels()
```
```
all_levels(backend::Backend; backend)
```

all_shapes

```
all_shapes()
```
```
all_shapes(backend::Backend; backend)
```

all_walls

```
all_walls()
```
```
all_walls(backend::Backend; backend)
```

all_walls_at_level

```
all_walls_at_level(level)
```

all_walls_at_level(level, backend::Backend; backend)

and_delete_shape

```
and_delete_shape(r, shape::Shape)
```

and_delete_shapes

and_delete_shapes(r, shapes::Vector{<:Shape})

```
and_delete_shapes(r, paths)
```

and_mark_deleted

```
and_mark_deleted(b::Backend, r, shape)
```

angle_between

```
angle_between(v1, v2)
```

annulus

```
annulus()
```
```
annulus(center)
```
```
annulus(center, outer_radius)
```

annulus(center, outer_radius, inner_radius; center, outer_radius, inner_radius)

annulus_area

```
annulus_area(rₒ, rᵢ)
```

arc

```
arc()
```
```
arc(center)
```
```
arc(center, radius)
```
```
arc(center, radius, start_angle)
```

arc(center, radius, start_angle, amplitude)

arc(center, radius, start_angle, amplitude, material; center, radius, start_angle, amplitude, material, ref)

arc_amplitude

```
arc_amplitude(v::Arc)
```

arc_center

```
arc_center(v::Arc)
```

arc_material

```
arc_material(v::Arc)
```

arc_path

```
arc_path()
```
```
arc_path(center::Loc)
```
```
arc_path(center::Loc, radius::Real)
```

arc_path(center::Loc, radius::Real, start_angle::Real)

arc_path(center::Loc, radius::Real, start_angle::Real, amplitude::Real)

arc_radius

```
arc_radius(v::Arc)
```

arc_start_angle

```
arc_start_angle(v::Arc)
```

autocad_command

```
autocad_command(s::String)
```

backend

```
backend(backend::Backend)
```
```
backend(s::KhepriBase.Proxy)
```

backend_bounding_box

backend_bounding_box(backend::Backend, shape::Shape)

backend_family

backend_family(b::Backend, family::Family)

backend_fill_curves

backend_fill_curves(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, ref::Int64)

backend_fill_curves(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, refs::Vector{Int64})

```
backend_fill_curves(b, ids)
```

backend_frame_at

backend_frame_at(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Shape2D, u::Real, v::Real)

backend_frame_at(b::Backend, s::Shape2D, u::Real, v::Real)

backend_frame_at(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Circle, t::Real)

backend_frame_at(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, c::Shape1D, t::Real)

```
backend_frame_at(b, c, t)
```

backend_map_division

backend_map_division(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, f::Function, s::Shape1D, n::Int64)

backend_map_division(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, f::Function, s::SurfaceGrid, nu::Int64, nv::Int64)

backend_map_division(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, f::Function, s::Shape2D, nu::Int64, nv::Int64)

backend_name

```
backend_name(b::SocketBackend)
```
```
backend_name(b::Backend)
```

backend_surface_boundary

backend_surface_boundary(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Shape2D)

backend_surface_domain

backend_surface_domain(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Shape2D)

beam

```
beam()
```
```
beam(cb::Loc, ct::Loc)
```
```
beam(cb::Loc, ct::Loc, Angle::Real)
```

beam(cb::Loc, ct::Loc, Angle::Real, Family::BeamFamily; angle, family)

```
beam(cb)
```
```
beam(cb, h)
```
```
beam(cb, h, angle)
```

beam(cb, h, angle, family; cb, h, angle, family, ref)

beam_angle

```
beam_angle(v::Beam)
```

beam_cb

```
beam_cb(v::Beam)
```

beam_family

```
beam_family()
```
```
beam_family(Name::String)
```

beam_family(Name::String, Profile::ClosedPath)

beam_family(Name::String, Profile::ClosedPath, Material::Material; name, profile, material, based_on, implemented_as, data)

```
beam_family(v::Beam)
```

beam_family_element

```
beam_family_element(family::Family)
```

beam_family_element(family::Family, implemented_as; name, profile, material)

beam_h

```
beam_h(v::Beam)
```

before_connecting

before_connecting(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64})

```
before_connecting(b::RemoteBackend)
```

block

```
block()
```
```
block(name)
```
```
block(name, shapes; name, shapes, ref)
```

block_instance

```
block_instance()
```
```
block_instance(block)
```
```
block_instance(block, loc)
```

block_instance(block, loc, scale; block, loc, scale, ref)

block_instance_block

```
block_instance_block(v::BlockInstance)
```

block_instance_loc

```
block_instance_loc(v::BlockInstance)
```

block_instance_scale

```
block_instance_scale(v::BlockInstance)
```

block_name

```
block_name(v::Block)
```

block_shapes

```
block_shapes(v::Block)
```

bottom_aligned_rectangular_profile

```
bottom_aligned_rectangular_profile()
```

bottom_aligned_rectangular_profile(Width::Real)

bottom_aligned_rectangular_profile(Width::Real, Height::Real; width, height)

bounding_box

```
bounding_box()
```
```
bounding_box(shape::Shape)
```
```
bounding_box(shapes::Vector{<:Shape})
```

box

```
box()
```
```
box(c0::Loc, c1::Loc, others...)
```
```
box(c)
```
```
box(c, dx)
```
```
box(c, dx, dy)
```
```
box(c, dx, dy, dz)
```

box(c, dx, dy, dz, material; c, dx, dy, dz, material, ref)

box_c

```
box_c(v::Box)
```

box_dx

```
box_dx(v::Box)
```

box_dy

```
box_dy(v::Box)
```

box_dz

```
box_dz(v::Box)
```

box_material

```
box_material(v::Box)
```

capture_shape

```
capture_shape()
```
```
capture_shape(s)
```

capture_shapes

```
capture_shapes()
```
```
capture_shapes(ss)
```

center_scaled_cs

center_scaled_cs(cs::KhepriBase.CS, x::Real, y::Real, z::Real)

center_scaled_cs(p::XYZ, x::Real, y::Real, z::Real)

centered_rectangular_path

```
centered_rectangular_path(p, dx, dy)
```

centroid

```
centroid(s::Sphere)
```
```
centroid(s::Cylinder)
```

chair

```
chair()
```
```
chair(loc::Loc, angle::Real)
```

chair(loc::Loc, angle::Real, level::Level)

chair(loc::Loc, angle::Real, level::Level, family::ChairFamily)

```
chair(loc)
```
```
chair(loc, level)
```

chair(loc, level, family; loc, level, family, ref)

chair_family

```
chair_family()
```
```
chair_family(Name::String)
```

chair_family(Name::String, Length::Real)

chair_family(Name::String, Length::Real, Width::Real)

chair_family(Name::String, Length::Real, Width::Real, Height::Real)

chair_family(Name::String, Length::Real, Width::Real, Height::Real, Seat_height::Real)

chair_family(Name::String, Length::Real, Width::Real, Height::Real, Seat_height::Real, Thickness::Real)

chair_family(Name::String, Length::Real, Width::Real, Height::Real, Seat_height::Real, Thickness::Real, Material::Material; name, length, width, height, seat_height, thickness, material, based_on, implemented_as, data)

```
chair_family(v::Chair)
```

chair_family_element

```
chair_family_element(family::Family)
```

chair_family_element(family::Family, implemented_as; name, length, width, height, seat_height, thickness, material)

chair_level

```
chair_level(v::Chair)
```

chair_loc

```
chair_loc(v::Chair)
```

changed_shape

```
changed_shape(shapes::Vector{<:Shape})
```

changed_shape(shapes::Vector{<:Shape}, backend::Backend; backend)

circle

```
circle()
```
```
circle(center)
```
```
circle(center, radius)
```

circle(center, radius, material; center, radius, material, ref)

circle_area

```
circle_area(r)
```

circle_center

```
circle_center(v::Circle)
```

circle_from_three_points

circle_from_three_points(p0::Loc, p1::Loc, p2::Loc)

circle_material

```
circle_material(v::Circle)
```

circle_radius

```
circle_radius(v::Circle)
```

circular_path

```
circular_path()
```
```
circular_path(Center::Loc)
```

circular_path(Center::Loc, Radius::Real; center, radius)

circular_profile

```
circular_profile()
```
```
circular_profile(Radius::Real; radius)
```

clear_trace!

```
clear_trace!()
```

closed_line

```
closed_line()
```
```
closed_line(v0::Loc, v1::Loc, vs...)
```
```
closed_line(vertices)
```

closed_line(vertices, material; vertices, material, ref)

closed_line_material

```
closed_line_material(v::ClosedLine)
```

closed_line_vertices

```
closed_line_vertices(v::ClosedLine)
```

closed_path_ops

```
closed_path_ops(start, ops...)
```

closed_path_sequence

```
closed_path_sequence(paths...)
```

closed_polygonal_path

```
closed_polygonal_path()
```
```
closed_polygonal_path(vertices)
```

closed_spline

```
closed_spline()
```
```
closed_spline(points)
```

closed_spline(points, material; points, material, ref)

```
closed_spline(v0, v1, vs...)
```

closed_spline_material

```
closed_spline_material(v::ClosedSpline)
```

closed_spline_path

```
closed_spline_path()
```
```
closed_spline_path(vertices)
```

closed_spline_points

```
closed_spline_points(v::ClosedSpline)
```

closest_vertices_indexes

```
closest_vertices_indexes(pts1, pts2)
```

collect_ref

collect_ref(b::Backend{K, T}) where {K, T}

collect_ref(b::Backend{K, T}, r::EmptyRef{K, T}) where {K, T}

collect_ref(b::Backend{K, T}, r::NativeRef{K, T}) where {K, T}

collect_ref(b::Backend{K, T}, r::UnionRef{K, T}) where {K, T}

collect_ref(b::Backend{K, T}, r::SubtractionRef{K, T}) where {K, T}

```
collect_ref(b::Backend, s::Shape)
```

collect_ref(b::Backend, ss::Vector{<:Shape})

collecting_shapes

```
collecting_shapes(fn)
```

column

```
column()
```
```
column(cb)
```
```
column(cb, angle)
```
```
column(cb, angle, bottom_level)
```

column(cb, angle, bottom_level, top_level)

column(cb, angle, bottom_level, top_level, family; cb, angle, bottom_level, top_level, family, ref)

column_angle

```
column_angle(v::Column)
```

column_bottom_level

```
column_bottom_level(v::Column)
```

column_cb

```
column_cb(v::Column)
```

column_family

```
column_family()
```
```
column_family(Name::String)
```

column_family(Name::String, Profile::ClosedPath)

column_family(Name::String, Profile::ClosedPath, Material::Material; name, profile, material, based_on, implemented_as, data)

```
column_family(v::Column)
```

column_family_element

```
column_family_element(family::Family)
```

column_family_element(family::Family, implemented_as; name, profile, material)

column_top_level

```
column_top_level(v::Column)
```

cone

```
cone()
```
```
cone(cb::Loc, r::Real, ct::Loc)
```
```
cone(cb)
```
```
cone(cb, r)
```
```
cone(cb, r, h)
```

cone(cb, r, h, material; cb, r, h, material, ref)

cone_cb

```
cone_cb(v::Cone)
```

cone_frustum

```
cone_frustum()
```

cone_frustum(cb::Loc, rb::Real, ct::Loc, rt::Real; material)

```
cone_frustum(cb)
```
```
cone_frustum(cb, rb)
```
```
cone_frustum(cb, rb, h)
```
```
cone_frustum(cb, rb, h, rt)
```

cone_frustum(cb, rb, h, rt, material; cb, rb, h, rt, material, ref)

cone_frustum_cb

```
cone_frustum_cb(v::ConeFrustum)
```

cone_frustum_h

```
cone_frustum_h(v::ConeFrustum)
```

cone_frustum_material

```
cone_frustum_material(v::ConeFrustum)
```

cone_frustum_rb

```
cone_frustum_rb(v::ConeFrustum)
```

cone_frustum_rt

```
cone_frustum_rt(v::ConeFrustum)
```

cone_h

```
cone_h(v::Cone)
```

cone_material

```
cone_material(v::Cone)
```

cone_r

```
cone_r(v::Cone)
```

connection

```
connection(b::RemoteBackend)
```
```
connection(b::IOBufferBackend)
```

cons

```
cons(h::T, t::List{L}) where {T, L}
```

create_layer

```
create_layer(args...)
```

cross

cross(a::StaticArraysCore.StaticArray{Tuple{N}, T, 1} where {N, T}, b::StaticArraysCore.StaticArray{Tuple{N}, T, 1} where {N, T})

cross(a::AbstractVector, b::AbstractVector)

```
cross(v::Vec, w::Vec)
```

crossref

```
crossref(as, bs)
```

crossref_holistic

```
crossref_holistic(arr1, arr2)
```

cs_from_o_phi

```
cs_from_o_phi(o::Loc, phi::Real)
```

cs_from_o_vx_vy

cs_from_o_vx_vy(o::Loc, vx::Vec, vy::Vec)

cs_from_o_vx_vy_vz

cs_from_o_vx_vy_vz(o::Loc, ux::Vec, uy::Vec, uz::Vec)

cs_from_o_vz

```
cs_from_o_vz(o::Loc, n::Vec)
```

cuboid

```
cuboid()
```
```
cuboid(b0)
```
```
cuboid(b0, b1)
```
```
cuboid(b0, b1, b2)
```
```
cuboid(b0, b1, b2, b3)
```
```
cuboid(b0, b1, b2, b3, t0)
```
```
cuboid(b0, b1, b2, b3, t0, t1)
```
```
cuboid(b0, b1, b2, b3, t0, t1, t2)
```
```
cuboid(b0, b1, b2, b3, t0, t1, t2, t3)
```

cuboid(b0, b1, b2, b3, t0, t1, t2, t3, material; b0, b1, b2, b3, t0, t1, t2, t3, material, ref)

cuboid_b0

```
cuboid_b0(v::Cuboid)
```

cuboid_b1

```
cuboid_b1(v::Cuboid)
```

cuboid_b2

```
cuboid_b2(v::Cuboid)
```

cuboid_b3

```
cuboid_b3(v::Cuboid)
```

cuboid_material

```
cuboid_material(v::Cuboid)
```

cuboid_t0

```
cuboid_t0(v::Cuboid)
```

cuboid_t1

```
cuboid_t1(v::Cuboid)
```

cuboid_t2

```
cuboid_t2(v::Cuboid)
```

cuboid_t3

```
cuboid_t3(v::Cuboid)
```

cull

```
cull(template, as)
```

current_backend

```
current_backend()
```

current_backend(bs::Tuple{Vararg{Backend}})

```
current_backend(b::Backend)
```

current_layer

```
current_layer()
```

current_layer(backends::Tuple{Vararg{Backend}})

```
current_layer(layer)
```

current_layer(layer, backends::Tuple{Vararg{Backend}})

curtain_wall

```
curtain_wall()
```

curtain_wall(b::Backend, s, path::Path, bottom::Real, height::Real, thickness::Real, kind::Symbol)

curtain_wall(p0::Loc, p1::Loc; bottom_level, top_level, family, offset)

```
curtain_wall(path)
```
```
curtain_wall(path, bottom_level)
```

curtain_wall(path, bottom_level, top_level)

curtain_wall(path, bottom_level, top_level, family)

curtain_wall(path, bottom_level, top_level, family, offset; path, bottom_level, top_level, family, offset, ref)

curtain_wall_bottom_level

curtain_wall_bottom_level(v::CurtainWall)

curtain_wall_family

```
curtain_wall_family()
```
```
curtain_wall_family(Name::String)
```

curtain_wall_family(Name::String, Max_panel_dx::Real)

curtain_wall_family(Name::String, Max_panel_dx::Real, Max_panel_dy::Real)

curtain_wall_family(Name::String, Max_panel_dx::Real, Max_panel_dy::Real, Panel::PanelFamily)

curtain_wall_family(Name::String, Max_panel_dx::Real, Max_panel_dy::Real, Panel::PanelFamily, Boundary_frame::CurtainWallFrameFamily)

curtain_wall_family(Name::String, Max_panel_dx::Real, Max_panel_dy::Real, Panel::PanelFamily, Boundary_frame::CurtainWallFrameFamily, Mullion_frame::CurtainWallFrameFamily)

curtain_wall_family(Name::String, Max_panel_dx::Real, Max_panel_dy::Real, Panel::PanelFamily, Boundary_frame::CurtainWallFrameFamily, Mullion_frame::CurtainWallFrameFamily, Transom_frame::CurtainWallFrameFamily; name, max_panel_dx, max_panel_dy, panel, boundary_frame, mullion_frame, transom_frame, based_on, implemented_as, data)

```
curtain_wall_family(v::CurtainWall)
```

curtain_wall_family_element

curtain_wall_family_element(family::Family)

curtain_wall_family_element(family::Family, implemented_as; name, max_panel_dx, max_panel_dy, panel, boundary_frame, mullion_frame, transom_frame)

curtain_wall_frame_family

```
curtain_wall_frame_family()
```
```
curtain_wall_frame_family(Name::String)
```

curtain_wall_frame_family(Name::String, Width::Real)

curtain_wall_frame_family(Name::String, Width::Real, Depth::Real)

curtain_wall_frame_family(Name::String, Width::Real, Depth::Real, Depth_offset::Real)

curtain_wall_frame_family(Name::String, Width::Real, Depth::Real, Depth_offset::Real, Right_material::Material)

curtain_wall_frame_family(Name::String, Width::Real, Depth::Real, Depth_offset::Real, Right_material::Material, Left_material::Material)

curtain_wall_frame_family(Name::String, Width::Real, Depth::Real, Depth_offset::Real, Right_material::Material, Left_material::Material, Side_material::Material; name, width, depth, depth_offset, right_material, left_material, side_material, based_on, implemented_as, data)

curtain_wall_frame_family_element

curtain_wall_frame_family_element(family::Family)

curtain_wall_frame_family_element(family::Family, implemented_as; name, width, depth, depth_offset, right_material, left_material, side_material)

curtain_wall_offset

```
curtain_wall_offset(v::CurtainWall)
```

curtain_wall_path

curtain_wall_path(b::Backend, s::CurtainWall, panel_family::PanelFamily)

curtain_wall_path(b::Backend, s::CurtainWall, panel_family::Family)

```
curtain_wall_path(v::CurtainWall)
```

curtain_wall_top_level

```
curtain_wall_top_level(v::CurtainWall)
```

curve_domain

```
curve_domain(s::Shape1D)
```

curve_domain(s::Shape1D, backend::Backend)

cx

```
cx(p::Union{Loc, Vec})
```

cy

```
cy(p::Union{Loc, Vec})
```

cyl

```
cyl(rho::Real, phi::Real, z::Real)
```

cyl(rho::Real, phi::Real, z::Real, cs::KhepriBase.CS)

cyl_phi

```
cyl_phi(p::Union{Loc, Vec})
```

cyl_rho

```
cyl_rho(p::Union{Loc, Vec})
```

cyl_z

```
cyl_z(p::Union{Loc, Vec})
```

cylinder

```
cylinder()
```

cylinder(cb::Loc, r::Real, ct::Loc; material)

```
cylinder(cb)
```
```
cylinder(cb, r)
```
```
cylinder(cb, r, h)
```

cylinder(cb, r, h, material; cb, r, h, material, ref)

cylinder_cb

```
cylinder_cb(v::Cylinder)
```

cylinder_h

```
cylinder_h(v::Cylinder)
```

cylinder_material

```
cylinder_material(v::Cylinder)
```

cylinder_r

```
cylinder_r(v::Cylinder)
```

cz

```
cz(p::Union{Loc, Vec})
```

decode

decode(ns::Union{Val{:CS}, Val{:PY}}, t::Union{Val{:void}, Val{:None}}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, ::Union{Val{:string}, Val{:String}, Val{:str}}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Tuple{T1, T2}, c::IO) where {T1, T2}

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Tuple{T1, T2, T3}, c::IO) where {T1, T2, T3}

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Tuple{T1, T2, T3, T4}, c::IO) where {T1, T2, T3, T4}

decode(ns::Val{NS}, t::Array{Tuple{T1, T2}, 1}, c::IO) where {NS, T1, T2}

decode(ns::Val{NS}, t::Vector{T}, c::IO) where {NS, T}

decode(::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Val{:int}, c::IO)

decode(::Union{Val{:CS}, Val{:CPP}}, t::Val{:long}, c::IO)

decode(::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Val{:byte}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, ::Val{:Color}, c::IO)

decode(ns::Union{Val{:CS}, Val{:PY}}, t::Val{:bool}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}}, t::Val{:double}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, ::Val{:RGBA}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, ::Val{:double3}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}}, t::Val{:float}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, ::Val{:RGB}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, ::Val{:float3}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Val{:address}, c::IO)

decode(ns::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Val{:size}, c::IO)

decode(::Union{Val{:CS}, Val{:CPP}, Val{:PY}}, t::Val{:short}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:Color}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:Frame3d}, c::IO)

decode(::Val{:ACAD}, ::Val{:Vector3d}, c::IO)

decode(::Val{:ACAD}, ::Val{:Point3d}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:Material}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:FloorFamily}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:BIMLevel}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:ObjectId}, c::IO)

decode(ns::Val{:ACAD}, ::Val{:Entity}, c::IO)

decode(::Val{:ACAD}, t::Val{T}, c::IO) where T

decode(ns::Val{:PY}, t::Val{:float}, c::IO)

decode(ns::Val{:CS}, ::Val{:Guid}, c::IO)

decode(ns::Val{:CS}, ::Val{:DateTime}, c::IO)

decode_or_error

decode_or_error(ns::Val{NS}, t::Val{T}, c::IO, err) where {NS, T}

default_view

```
default_view()
```

delete_all_refs

```
delete_all_refs()
```

delete_all_refs(backends::Tuple{Vararg{Backend}}; backends)

delete_all_shapes

```
delete_all_shapes()
```

delete_all_shapes(backends::Tuple{Vararg{Backend}}; backends)

delete_all_shapes_in_layer

```
delete_all_shapes_in_layer(layer)
```

delete_all_shapes_in_layer(layer, backends::Tuple{Vararg{Backend}})

delete_shape

```
delete_shape(s::Shape)
```

delete_shape(s::Shape, backends::Tuple{Vararg{Backend}}; backends)

delete_shapes

```
delete_shapes()
```
```
delete_shapes(ss::Vector{<:Shape})
```
```
delete_shapes(ss::Vector{<:Shape}, bs)
```

dimension

```
dimension()
```
```
dimension(from)
```
```
dimension(from, to)
```
```
dimension(from, to, text)
```
```
dimension(from, to, text, size)
```

dimension(from, to, text, size, material; from, to, text, size, material, ref)

dimension_from

```
dimension_from(v::Dimension)
```

dimension_material

```
dimension_material(v::Dimension)
```

dimension_size

```
dimension_size(v::Dimension)
```

dimension_text

```
dimension_text(v::Dimension)
```

dimension_to

```
dimension_to(v::Dimension)
```

disable_update

```
disable_update()
```

disable_update(backend::Backend; backend)

distance

```
distance(p::XYZ, q::XYZ)
```

division

```
division(obj, n::Real)
```
```
division(t0, t1, n::Real)
```

division(t0, t1, n::Real, include_last::Bool)

dolly_effect_back

dolly_effect_back(delta, camera, target, lens, frames)

dolly_effect_forth

dolly_effect_forth(delta, camera, target, lens, frames)

door

```
door()
```
```
door(wall)
```
```
door(wall, loc)
```
```
door(wall, loc, flip_x)
```
```
door(wall, loc, flip_x, flip_y)
```

door(wall, loc, flip_x, flip_y, family; wall, loc, flip_x, flip_y, family, ref)

door_family

```
door_family()
```
```
door_family(Name::String)
```
```
door_family(Name::String, Width::Real)
```

door_family(Name::String, Width::Real, Height::Real)

door_family(Name::String, Width::Real, Height::Real, Thickness::Real)

door_family(Name::String, Width::Real, Height::Real, Thickness::Real, Right_material::Material)

door_family(Name::String, Width::Real, Height::Real, Thickness::Real, Right_material::Material, Left_material::Material)

door_family(Name::String, Width::Real, Height::Real, Thickness::Real, Right_material::Material, Left_material::Material, Side_material::Material; name, width, height, thickness, right_material, left_material, side_material, based_on, implemented_as, data)

```
door_family(v::Door)
```

door_family_element

```
door_family_element(family::Family)
```

door_family_element(family::Family, implemented_as; name, width, height, thickness, right_material, left_material, side_material)

door_flip_x

```
door_flip_x(v::Door)
```

door_flip_y

```
door_flip_y(v::Door)
```

door_loc

```
door_loc(v::Door)
```

door_wall

```
door_wall(v::Door)
```

ellipse

```
ellipse()
```
```
ellipse(center)
```
```
ellipse(center, radius_x)
```
```
ellipse(center, radius_x, radius_y)
```

ellipse(center, radius_x, radius_y, material; center, radius_x, radius_y, material, ref)

ellipse_center

```
ellipse_center(v::Ellipse)
```

ellipse_material

```
ellipse_material(v::Ellipse)
```

ellipse_radius_x

```
ellipse_radius_x(v::Ellipse)
```

ellipse_radius_y

```
ellipse_radius_y(v::Ellipse)
```

elliptic_arc

```
elliptic_arc()
```
```
elliptic_arc(center)
```
```
elliptic_arc(center, radius_x)
```

elliptic_arc(center, radius_x, radius_y)

elliptic_arc(center, radius_x, radius_y, start_angle)

elliptic_arc(center, radius_x, radius_y, start_angle, amplitude)

elliptic_arc(center, radius_x, radius_y, start_angle, amplitude, material; center, radius_x, radius_y, start_angle, amplitude, material, ref)

elliptic_arc_amplitude

```
elliptic_arc_amplitude(v::EllipticArc)
```

elliptic_arc_center

```
elliptic_arc_center(v::EllipticArc)
```

elliptic_arc_material

```
elliptic_arc_material(v::EllipticArc)
```

elliptic_arc_radius_x

```
elliptic_arc_radius_x(v::EllipticArc)
```

elliptic_arc_radius_y

```
elliptic_arc_radius_y(v::EllipticArc)
```

elliptic_arc_start_angle

elliptic_arc_start_angle(v::EllipticArc)

empty_path

```
empty_path()
```

empty_shape

```
empty_shape(; ref)
```

enable_update

```
enable_update()
```

enable_update(backend::Backend; backend)

ensure_ref

ensure_ref(b::Backend{K, T}, rs::Vector{T}) where {K, T}

ensure_ref(b::Backend{K, T}, v::GenericRef{K, T}) where {K, T}

ensure_ref(b::Backend{K, T}, v::Vector{<:S}) where {K, T, S}

ensure_ref(b::Backend{K, T}, v::KhepriBase.Proxy) where {K, T}

ensure_ref(b::Backend{K, T}, r::T) where {K, T}

errormsg

```
errormsg(e)
```

evaluate_derivative

evaluate_derivative(spline::Dierckx.Spline2D, x::AbstractVector, y::AbstractVector, dx::Int64, dy::Int64)

evaluate_derivative(spline::Dierckx.Spline2D, x::Number, y::Number, dx::Int64, dy::Int64)

extrusion

```
extrusion()
```
```
extrusion(profile)
```
```
extrusion(profile, h::Real)
```
```
extrusion(profile, v)
```
```
extrusion(profile, v, cb)
```

extrusion(profile, v, cb, material; profile, v, cb, material, ref)

extrusion_cb

```
extrusion_cb(v::Extrusion)
```

extrusion_material

```
extrusion_material(v::Extrusion)
```

extrusion_profile

```
extrusion_profile(v::Extrusion)
```

extrusion_v

```
extrusion_v(v::Extrusion)
```

failed_connecting

```
failed_connecting(b::RemoteBackend)
```

family

```
family(f::FamilyInstance)
```
```
family(f::Family)
```

family_ref

```
family_ref(s::KhepriBase.BIMShape)
```
```
family_ref(b::Backend, f::Family)
```

film_pathname

```
film_pathname()
```

finish_film

```
finish_film()
```

force_realize

force_realize(b::Backend, s::KhepriBase.Proxy)

```
force_realize(s::KhepriBase.Proxy)
```

frame_at

```
frame_at(c::Shape1D, t::Real)
```

frame_at(s::SurfaceRectangle, u::Real, v::Real)

frame_at(s::SurfaceCircle, u::Real, v::Real)

frame_at(s::SurfaceGrid, u::Real, v::Real)

```
frame_at(s::Shape2D, u::Real, v::Real)
```

frame_filename

frame_filename(filename::String, i::Integer)

free_column

```
free_column()
```
```
free_column(cb::Loc, ct::Loc)
```

free_column(cb::Loc, ct::Loc, Angle::Real)

free_column(cb::Loc, ct::Loc, Angle::Real, Family::ColumnFamily; angle, family)

```
free_column(cb)
```
```
free_column(cb, h)
```
```
free_column(cb, h, angle)
```

free_column(cb, h, angle, family; cb, h, angle, family, ref)

free_column_angle

```
free_column_angle(v::FreeColumn)
```

free_column_cb

```
free_column_cb(v::FreeColumn)
```

free_column_family

```
free_column_family(v::FreeColumn)
```

free_column_h

```
free_column_h(v::FreeColumn)
```

get_view

```
get_view()
```
```
get_view(backend::Backend; backend)
```

grid

```
grid(ptss)
```

grid_interpolator

```
grid_interpolator(ptss)
```

ground

```
ground()
```

ground(b::Backend, level::Loc, color::RGB)

```
ground(level::Real)
```
```
ground(level::Real, material::Material)
```

ground(level::Real, material::Material, backend::Backend)

has_boolean_ops

```
has_boolean_ops(::Type{<:Backend})
```

has_current_backend

```
has_current_backend()
```

head

```
head(x::Cons{T}) where T
```

highlight_shape

```
highlight_shape(s::Shape)
```

highlight_shape(s::Shape, backends::Tuple{Vararg{Backend}}; backends)

highlight_shapes

```
highlight_shapes()
```
```
highlight_shapes(ss::Vector{<:Shape})
```

highlight_shapes(ss::Vector{<:Shape}, bs)

i_profile

```
i_profile()
```
```
i_profile(Width::Real)
```

i_profile(Width::Real, Height::Real; width, height, web_thickness, flange_thickness)

ieslight

```
ieslight()
```
```
ieslight(file)
```
```
ieslight(file, loc)
```
```
ieslight(file, loc, dir)
```
```
ieslight(file, loc, dir, alpha)
```
```
ieslight(file, loc, dir, alpha, beta)
```

ieslight(file, loc, dir, alpha, beta, gamma; file, loc, dir, alpha, beta, gamma, ref)

ieslight_alpha

```
ieslight_alpha(v::Ieslight)
```

ieslight_beta

```
ieslight_beta(v::Ieslight)
```

ieslight_dir

```
ieslight_dir(v::Ieslight)
```

ieslight_file

```
ieslight_file(v::Ieslight)
```

ieslight_gamma

```
ieslight_gamma(v::Ieslight)
```

ieslight_loc

```
ieslight_loc(v::Ieslight)
```

illustrate_path

```
illustrate_path(path)
```

in_cs

in_cs(path::T, cs::KhepriBase.CS) where T<:Union{ClosedPathSequence, OpenPathSequence, PathSet, Region}

```
in_cs(p::Loc, cs::KhepriBase.CS)
```
```
in_cs(p::Vec, cs::KhepriBase.CS)
```

in_cs(ps::Vector{<:Loc}, cs::KhepriBase.CS)

in_cs(path::ClosedSplinePath, cs::KhepriBase.CS)

in_cs(from_cs::KhepriBase.CS, to_cs::KhepriBase.CS)

in_cs(path::ClosedPolygonalPath, cs::KhepriBase.CS)

in_cs(path::CircularPath, cs::KhepriBase.CS)

```
in_cs(path::ArcPath, cs::KhepriBase.CS)
```

in_cs(path::RectangularPath, cs::KhepriBase.CS)

in_cs(path::OpenPolygonalPath, cs::KhepriBase.CS)

in_cs(path::OpenSplinePath, cs::KhepriBase.CS)

in_cs(path::KhepriBase.PointPath, cs::KhepriBase.CS)

```
in_cs(p, q)
```

in_world

```
in_world(p)
```

inject_polygon_vertices_at_indexes

inject_polygon_vertices_at_indexes(pts1, pts2, ::Any)

inner_paths

```
inner_paths(region::Region)
```

intermediate_loc

```
intermediate_loc(p::Loc, q::Loc)
```

intermediate_loc(p::Loc, q::Loc, f::Real)

internalize_shape

```
internalize_shape()
```
```
internalize_shape(s)
```

internalize_shapes

```
internalize_shapes()
```
```
internalize_shapes(ss)
```

interpolate_view_save_frames

interpolate_view_save_frames(ctl_positions, nframes)

intersect_ref

intersect_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::UniversalRef{K, T}) where {K, T}

intersect_ref(b::Backend{K, T}, r0::UniversalRef{K, T}, r1::GenericRef{K, T}) where {K, T}

intersect_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::EmptyRef{K, T}) where {K, T}

intersect_ref(b::Backend{K, T}, r0::EmptyRef{K, T}, r1::GenericRef{K, T}) where {K, T}

intersect_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::UnionRef{K, T}) where {K, T}

intersect_ref(b::Backend{K, T}, r0::UnionRef{K, T}, r1::GenericRef{K, T}) where {K, T}

intersect_ref(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, r0::NativeRef{KhepriAutoCAD.ACADKey, Int64}, r1::NativeRef{KhepriAutoCAD.ACADKey, Int64})

intersect_ref(b::Backend{K, T}) where {K, T}

intersection

```
intersection(shapes::Vector{<:Shape})
```
```
intersection(shape::Shape, shapes...)
```

intersection_shape

```
intersection_shape()
```
```
intersection_shape(shapes; shapes, ref)
```

intersection_shape_shapes

intersection_shape_shapes(v::IntersectionShape)

inverse_transformation

```
inverse_transformation(p::Loc)
```

is_annulus

```
is_annulus(v::Annulus)
```
```
is_annulus(v)
```

is_arc

```
is_arc(v::Arc)
```
```
is_arc(v)
```

is_beam

```
is_beam(v::Beam)
```
```
is_beam(v)
```

is_beam_family

```
is_beam_family(v::BeamFamily)
```
```
is_beam_family(v)
```

is_block

```
is_block(v::Block)
```
```
is_block(v)
```

is_block_instance

```
is_block_instance(v::BlockInstance)
```
```
is_block_instance(v)
```

is_box

```
is_box(v::Box)
```
```
is_box(v)
```

is_chair

```
is_chair(v::Chair)
```
```
is_chair(v)
```

is_chair_family

```
is_chair_family(v::ChairFamily)
```
```
is_chair_family(v)
```

is_circle

```
is_circle(v::Circle)
```
```
is_circle(v)
```

is_closed_line

```
is_closed_line(v::ClosedLine)
```
```
is_closed_line(v)
```

is_closed_spline

```
is_closed_spline(v::ClosedSpline)
```
```
is_closed_spline(v)
```

is_column

```
is_column(v::Column)
```
```
is_column(v)
```

is_column_family

```
is_column_family(v::ColumnFamily)
```
```
is_column_family(v)
```

is_cone

```
is_cone(v::Cone)
```
```
is_cone(v)
```

is_cone_frustum

```
is_cone_frustum(v::ConeFrustum)
```
```
is_cone_frustum(v)
```

is_cuboid

```
is_cuboid(v::Cuboid)
```
```
is_cuboid(v)
```

is_curtain_wall

```
is_curtain_wall(v::CurtainWall)
```
```
is_curtain_wall(v)
```

is_curtain_wall_family

is_curtain_wall_family(v::CurtainWallFamily)

```
is_curtain_wall_family(v)
```

is_curtain_wall_frame_family

is_curtain_wall_frame_family(v::CurtainWallFrameFamily)

```
is_curtain_wall_frame_family(v)
```

is_cylinder

```
is_cylinder(v::Cylinder)
```
```
is_cylinder(v)
```

is_dimension

```
is_dimension(v::Dimension)
```
```
is_dimension(v)
```

is_door

```
is_door(v::Door)
```
```
is_door(v)
```

is_door_family

```
is_door_family(v::DoorFamily)
```
```
is_door_family(v)
```

is_ellipse

```
is_ellipse(v::Ellipse)
```
```
is_ellipse(v)
```

is_elliptic_arc

```
is_elliptic_arc(v::EllipticArc)
```
```
is_elliptic_arc(v)
```

is_empty_shape

```
is_empty_shape(v::EmptyShape)
```
```
is_empty_shape(v)
```

is_extrusion

```
is_extrusion(v::Extrusion)
```
```
is_extrusion(v)
```

is_free_column

```
is_free_column(v::FreeColumn)
```
```
is_free_column(v)
```

is_ieslight

```
is_ieslight(v::Ieslight)
```
```
is_ieslight(v)
```

is_intersection_shape

is_intersection_shape(v::IntersectionShape)

```
is_intersection_shape(v)
```

is_isosurface

```
is_isosurface(v::Isosurface)
```
```
is_isosurface(v)
```

is_layer

```
is_layer(v::Layer)
```
```
is_layer(v)
```

is_level

```
is_level(v::Level)
```
```
is_level(v)
```

is_line

```
is_line(v::Line)
```
```
is_line(v)
```

is_loft_curve_point

```
is_loft_curve_point(v::LoftCurvePoint)
```
```
is_loft_curve_point(v)
```

is_loft_curves

```
is_loft_curves(v::LoftCurves)
```
```
is_loft_curves(v)
```

is_loft_points

```
is_loft_points(v::LoftPoints)
```
```
is_loft_points(v)
```

is_loft_surface_point

is_loft_surface_point(v::LoftSurfacePoint)

```
is_loft_surface_point(v)
```

is_loft_surfaces

```
is_loft_surfaces(v::LoftSurfaces)
```
```
is_loft_surfaces(v)
```

is_material

```
is_material(v::Material)
```
```
is_material(v)
```

is_mirror

```
is_mirror(v::Mirror)
```
```
is_mirror(v)
```

is_move

```
is_move(v::Move)
```
```
is_move(v)
```

is_panel

```
is_panel(v::Panel)
```
```
is_panel(v)
```

is_panel_family

```
is_panel_family(v::PanelFamily)
```
```
is_panel_family(v)
```

is_parametric_surface

is_parametric_surface(v::ParametricSurface)

```
is_parametric_surface(v)
```

is_point

```
is_point(v::Point)
```
```
is_point(v)
```

is_pointlight

```
is_pointlight(v::Pointlight)
```
```
is_pointlight(v)
```

is_polygon

```
is_polygon(v::Polygon)
```
```
is_polygon(v)
```

is_prism

```
is_prism(v::Prism)
```
```
is_prism(v)
```

is_pyramid

```
is_pyramid(v::Pyramid)
```
```
is_pyramid(v)
```

is_pyramid_frustum

```
is_pyramid_frustum(v::PyramidFrustum)
```
```
is_pyramid_frustum(v)
```

is_rectangle

```
is_rectangle(v::Rectangle)
```
```
is_rectangle(v)
```

is_regular_polygon

```
is_regular_polygon(v::RegularPolygon)
```
```
is_regular_polygon(v)
```

is_regular_prism

```
is_regular_prism(v::RegularPrism)
```
```
is_regular_prism(v)
```

is_regular_pyramid

```
is_regular_pyramid(v::RegularPyramid)
```
```
is_regular_pyramid(v)
```

is_regular_pyramid_frustum

is_regular_pyramid_frustum(v::RegularPyramidFrustum)

```
is_regular_pyramid_frustum(v)
```

is_revolve_curve

```
is_revolve_curve(v::RevolveCurve)
```
```
is_revolve_curve(v)
```

is_revolve_point

```
is_revolve_point(v::RevolvePoint)
```
```
is_revolve_point(v)
```

is_revolve_surface

```
is_revolve_surface(v::RevolveSurface)
```
```
is_revolve_surface(v)
```

is_right_cuboid

```
is_right_cuboid(v::RightCuboid)
```
```
is_right_cuboid(v)
```

is_roof

```
is_roof(v::Roof)
```
```
is_roof(v)
```

is_roof_family

```
is_roof_family(v::RoofFamily)
```
```
is_roof_family(v)
```

is_rotate

```
is_rotate(v::Rotate)
```
```
is_rotate(v)
```

is_scale

```
is_scale(v::Scale)
```
```
is_scale(v)
```

is_slab

```
is_slab(v::Slab)
```
```
is_slab(v)
```

is_slab_family

```
is_slab_family(v::SlabFamily)
```
```
is_slab_family(v)
```

is_slice

```
is_slice(v::Slice)
```
```
is_slice(v)
```

is_sphere

```
is_sphere(v::Sphere)
```
```
is_sphere(v)
```

is_spline

```
is_spline(v::Spline)
```
```
is_spline(v)
```

is_spotlight

```
is_spotlight(v::Spotlight)
```
```
is_spotlight(v)
```

is_subtraction_shape2D

is_subtraction_shape2D(v::SubtractionShape2D)

```
is_subtraction_shape2D(v)
```

is_subtraction_shape3D

is_subtraction_shape3D(v::SubtractionShape3D)

```
is_subtraction_shape3D(v)
```

is_surface

```
is_surface(v::Surface)
```
```
is_surface(s::Shape2D)
```
```
is_surface(s::Shape)
```
```
is_surface(v)
```

is_surface_arc

```
is_surface_arc(v::SurfaceArc)
```
```
is_surface_arc(v)
```

is_surface_circle

```
is_surface_circle(v::SurfaceCircle)
```
```
is_surface_circle(v)
```

is_surface_ellipse

```
is_surface_ellipse(v::SurfaceEllipse)
```
```
is_surface_ellipse(v)
```

is_surface_elliptic_arc

is_surface_elliptic_arc(v::SurfaceEllipticArc)

```
is_surface_elliptic_arc(v)
```

is_surface_grid

```
is_surface_grid(v::SurfaceGrid)
```
```
is_surface_grid(v)
```

is_surface_mesh

```
is_surface_mesh(v::SurfaceMesh)
```
```
is_surface_mesh(v)
```

is_surface_path

```
is_surface_path(v::SurfacePath)
```
```
is_surface_path(v)
```

is_surface_polygon

```
is_surface_polygon(v::SurfacePolygon)
```
```
is_surface_polygon(v)
```

is_surface_rectangle

is_surface_rectangle(v::SurfaceRectangle)

```
is_surface_rectangle(v)
```

is_surface_regular_polygon

is_surface_regular_polygon(v::SurfaceRegularPolygon)

```
is_surface_regular_polygon(v)
```

is_sweep

```
is_sweep(v::Sweep)
```
```
is_sweep(v)
```

is_sweep_path

```
is_sweep_path(v::SweepPath)
```
```
is_sweep_path(v)
```

is_table

```
is_table(v::Table)
```
```
is_table(v)
```

is_table_and_chairs

```
is_table_and_chairs(v::TableAndChairs)
```
```
is_table_and_chairs(v)
```

is_table_chair_family

is_table_chair_family(v::TableChairFamily)

```
is_table_chair_family(v)
```

is_table_family

```
is_table_family(v::TableFamily)
```
```
is_table_family(v)
```

is_text

```
is_text(v::KhepriBase.Text)
```
```
is_text(v)
```

is_thicken

```
is_thicken(v::Thicken)
```
```
is_thicken(v)
```

is_torus

```
is_torus(v::Torus)
```
```
is_torus(v)
```

is_transform

```
is_transform(v::Transform)
```
```
is_transform(v)
```

is_truss_bar

```
is_truss_bar(v::TrussBar)
```
```
is_truss_bar(v)
```

is_truss_bar_family

```
is_truss_bar_family(v::TrussBarFamily)
```
```
is_truss_bar_family(v)
```

is_truss_node

```
is_truss_node(v::TrussNode)
```
```
is_truss_node(v)
```

is_truss_node_family

is_truss_node_family(v::TrussNodeFamily)

```
is_truss_node_family(v)
```

is_union_mirror

```
is_union_mirror(v::UnionMirror)
```
```
is_union_mirror(v)
```

is_union_shape

```
is_union_shape(v::UnionShape)
```
```
is_union_shape(v)
```

is_universal_shape

```
is_universal_shape(v::UniversalShape)
```
```
is_universal_shape(v)
```

is_unknown

```
is_unknown(v::Unknown)
```
```
is_unknown(v)
```

is_wall

```
is_wall(v::Wall)
```
```
is_wall(v)
```

is_wall_family

```
is_wall_family(v::WallFamily)
```
```
is_wall_family(v)
```

is_window

```
is_window(v::Window)
```
```
is_window(v)
```

is_window_family

```
is_window_family(v::WindowFamily)
```
```
is_window_family(v)
```

is_world_cs

```
is_world_cs(cs::KhepriBase.CS)
```

isosurface

```
isosurface()
```
```
isosurface(frep)
```
```
isosurface(frep, bounding_box)
```

isosurface(frep, bounding_box, material; frep, bounding_box, material, ref)

isosurface_bounding_box

```
isosurface_bounding_box(v::Isosurface)
```

isosurface_frep

```
isosurface_frep(v::Isosurface)
```

isosurface_material

```
isosurface_material(v::Isosurface)
```

iterate_quads

```
iterate_quads(f, ptss)
```

join_paths

join_paths(p1::OpenPolygonalPath, p2::OpenPolygonalPath)

join_walls

```
join_walls(wall1, wall2)
```
```
join_walls(walls...)
```

khepribase_interface_file

```
khepribase_interface_file()
```

layer

```
layer()
```
```
layer(name)
```
```
layer(name, active)
```

layer(name, active, color; name, active, color, ref)

layer_active

```
layer_active(v::Layer)
```

layer_color

```
layer_color(v::Layer)
```

layer_family

```
layer_family(name)
```
```
layer_family(name, color::RGB)
```

layer_name

```
layer_name(v::Layer)
```

length_at_location

```
length_at_location(path::Path, p::Loc)
```

length_at_location(path::Path, p::Loc, t0)

length_at_location(path::Path, p::Loc, t0, t1)

lens_zoom

lens_zoom(camera, target, delta, frames)

lens_zoom(camera, target, delta, frames, lens)

lens_zoom(camera, target, delta, frames, lens, aperture)

level

```
level()
```
```
level(height)
```

level(height, elements; height, elements, ref)

level_elements

```
level_elements(v::Level)
```

level_height

```
level_height(b::Backend, level)
```
```
level_height(v::Level)
```

lighting_analysis

```
lighting_analysis()
```

lighting_analysis(backend::Backend; backend)

line

```
line()
```
```
line(v0::Loc, v1::Loc, vs...)
```
```
line(vertices)
```

line(vertices, material; vertices, material, ref)

line_material

```
line_material(v::Line)
```

line_vertices

```
line_vertices(v::Line)
```

list

```
list()
```
```
list(gen::Base.Generator)
```
```
list(elts...)
```

loc_from_o_phi

```
loc_from_o_phi(o::Loc, phi::Real)
```

loc_from_o_rot_x

```
loc_from_o_rot_x(o::Loc, phi::Real)
```

loc_from_o_rot_y

```
loc_from_o_rot_y(o::Loc, phi::Real)
```

loc_from_o_rot_z

```
loc_from_o_rot_z(o::Loc, phi::Real)
```

loc_from_o_rot_zyx

loc_from_o_rot_zyx(o::Loc, z::Real, y::Real, x::Real)

loc_from_o_vx

```
loc_from_o_vx(o::Loc, vx::Vec)
```

loc_from_o_vx_vy

loc_from_o_vx_vy(o::Loc, vx::Vec, vy::Vec)

loc_from_o_vz

```
loc_from_o_vz(o::Loc, vz::Vec)
```

location_at

```
location_at(path::ArcPath, ϕ::Real)
```

location_at(path::CircularPath, ϕ::Real)

location_at(path::RectangularPath, d::Real)

location_at(path::Union{ClosedPolygonalPath, OpenPolygonalPath}, ϕ::Real)

location_at(path::Union{ClosedSplinePath, OpenSplinePath}, ϕ::Real)

location_at(interpolator::Dierckx.ParametricSpline, ϕ)

location_at(interpolator::Tuple{Dierckx.Spline2D, Dierckx.Spline2D, Dierckx.Spline2D}, u, v)

```
location_at(grid::Grid, u, v)
```

location_at_length

location_at_length(path::CircularPath, d::Real)

location_at_length(path::ArcPath, d::Real)

location_at_length(path::RectangularPath, d::Real)

location_at_length(path::OpenPolygonalPath, d::Real)

location_at_length(path::ClosedPolygonalPath, d::Real)

location_at_length(path::KhepriBase.PathOps, d::Real)

location_at_length(op::LineOp, start::Loc, d::Real)

location_at_length(op::ArcOp, start::Loc, d::Real)

location_at_length(path::Union{ClosedPathSequence, OpenPathSequence}, d::Real)

loft

```
loft()
```
```
loft(profiles::Vector{<:Shape})
```

loft(profiles::Vector{<:Shape}, rails::Vector{<:Shape})

loft(profiles::Vector{<:Shape}, rails::Vector{<:Shape}, ruled::Bool)

loft(profiles::Vector{<:Shape}, rails::Vector{<:Shape}, ruled::Bool, closed::Bool)

loft_curve_point

```
loft_curve_point()
```
```
loft_curve_point(profile)
```
```
loft_curve_point(profile, point)
```

loft_curve_point(profile, point, material; profile, point, material, ref)

loft_curve_point_material

loft_curve_point_material(v::LoftCurvePoint)

loft_curve_point_point

loft_curve_point_point(v::LoftCurvePoint)

loft_curve_point_profile

loft_curve_point_profile(v::LoftCurvePoint)

loft_curves

```
loft_curves()
```
```
loft_curves(profiles)
```
```
loft_curves(profiles, rails)
```
```
loft_curves(profiles, rails, ruled)
```

loft_curves(profiles, rails, ruled, closed)

loft_curves(profiles, rails, ruled, closed, material; profiles, rails, ruled, closed, material, ref)

loft_curves_closed

```
loft_curves_closed(v::LoftCurves)
```

loft_curves_material

```
loft_curves_material(v::LoftCurves)
```

loft_curves_profiles

```
loft_curves_profiles(v::LoftCurves)
```

loft_curves_rails

```
loft_curves_rails(v::LoftCurves)
```

loft_curves_ruled

```
loft_curves_ruled(v::LoftCurves)
```

loft_points

```
loft_points()
```
```
loft_points(profiles)
```
```
loft_points(profiles, rails)
```
```
loft_points(profiles, rails, ruled)
```

loft_points(profiles, rails, ruled, closed)

loft_points(profiles, rails, ruled, closed, material; profiles, rails, ruled, closed, material, ref)

loft_points_closed

```
loft_points_closed(v::LoftPoints)
```

loft_points_material

```
loft_points_material(v::LoftPoints)
```

loft_points_profiles

```
loft_points_profiles(v::LoftPoints)
```

loft_points_rails

```
loft_points_rails(v::LoftPoints)
```

loft_points_ruled

```
loft_points_ruled(v::LoftPoints)
```

loft_ruled

```
loft_ruled()
```
```
loft_ruled(profiles::Vector{<:Shape})
```

loft_surface_point

```
loft_surface_point()
```
```
loft_surface_point(profile)
```
```
loft_surface_point(profile, point)
```

loft_surface_point(profile, point, material; profile, point, material, ref)

loft_surface_point_material

loft_surface_point_material(v::LoftSurfacePoint)

loft_surface_point_point

loft_surface_point_point(v::LoftSurfacePoint)

loft_surface_point_profile

loft_surface_point_profile(v::LoftSurfacePoint)

loft_surfaces

```
loft_surfaces()
```
```
loft_surfaces(profiles)
```
```
loft_surfaces(profiles, rails)
```
```
loft_surfaces(profiles, rails, ruled)
```

loft_surfaces(profiles, rails, ruled, closed)

loft_surfaces(profiles, rails, ruled, closed, material; profiles, rails, ruled, closed, material, ref)

loft_surfaces_closed

```
loft_surfaces_closed(v::LoftSurfaces)
```

loft_surfaces_material

```
loft_surfaces_material(v::LoftSurfaces)
```

loft_surfaces_profiles

```
loft_surfaces_profiles(v::LoftSurfaces)
```

loft_surfaces_rails

```
loft_surfaces_rails(v::LoftSurfaces)
```

loft_surfaces_ruled

```
loft_surfaces_ruled(v::LoftSurfaces)
```

map_division

map_division(func::Function, path::OpenSplinePath, n::Integer)

map_division(f::Function, path::ClosedSplinePath, n::Integer)

```
map_division(f::Function, path::Path)
```

map_division(f::Function, path::Path, n::Integer)

map_division(f::Function, s::Shape1D, n::Int64)

map_division(f::Function, s::SurfaceGrid, nu::Int64, nv::Int64)

map_division(f::Function, s::SurfaceGrid, nu::Int64, nv::Int64, backend::Backend)

map_division(f::Function, s::Shape2D, nu::Int64, nv::Int64)

```
map_division(f, t0, t1, n::Real)
```

map_division(f, t0, t1, n::Real, include_last::Bool)

map_division(f, u0, u1, nu::Real, include_last_u::Bool, v0, v1, nv::Real)

map_division(f, u0, u1, nu::Real, v0, v1, nv::Real)

map_division(f, u0, u1, nu::Real, v0, v1, nv::Real, include_last_v::Bool)

map_division(f, u0, u1, nu::Real, include_last_u::Bool, v0, v1, nv::Real, include_last_v::Bool)

map_ref

map_ref(b::Backend{K, T}, f::Function) where {K, T}

map_ref(b::Backend{K, T}, f::Function, r::NativeRef{K, T}) where {K, T}

map_ref(b::Backend{K, T}, f::Function, r::UnionRef{K, T}) where {K, T}

map_ref(b::Backend{K, T}, f::Function, r::SubtractionRef{K, T}) where {K, T}

map_ref(b::Backend{K, T}, f::Function, r::KhepriBase.NativeRefs{K, T}) where {K, T}

map_ref(f::Function, b::Backend, s::Shape)

mark_deleted

mark_deleted(b::Backend, ss::Array{<:KhepriBase.Proxy})

```
mark_deleted(b::Backend, v::Table)
```
```
mark_deleted(b::Backend, v::Mirror)
```
```
mark_deleted(b::Backend, v::Rotate)
```
```
mark_deleted(b::Backend, v::Ellipse)
```

mark_deleted(b::Backend, v::TableAndChairs)

```
mark_deleted(b::Backend, v::Polygon)
```
```
mark_deleted(b::Backend, v::Move)
```
```
mark_deleted(b::Backend, v::Sweep)
```
```
mark_deleted(b::Backend, v::TrussNode)
```
```
mark_deleted(b::Backend, v::Pointlight)
```
```
mark_deleted(b::Backend, v::Spline)
```
```
mark_deleted(b::Backend, v::Isosurface)
```
```
mark_deleted(b::Backend, v::Transform)
```

mark_deleted(b::Backend, v::SurfacePath)

```
mark_deleted(b::Backend, v::Layer)
```

mark_deleted(b::Backend, v::UniversalShape)

```
mark_deleted(b::Backend, v::Panel)
```
```
mark_deleted(b::Backend, v::Door)
```

mark_deleted(b::Backend, v::LoftSurfaces)

mark_deleted(b::Backend, v::PyramidFrustum)

```
mark_deleted(b::Backend, v::Wall)
```
```
mark_deleted(b::Backend, v::Sphere)
```

mark_deleted(b::Backend, v::RevolveSurface)

mark_deleted(b::Backend, v::UnionMirror)

```
mark_deleted(b::Backend, v::Cuboid)
```
```
mark_deleted(b::Backend, v::Surface)
```

mark_deleted(b::Backend, v::IntersectionShape)

```
mark_deleted(b::Backend, v::Rectangle)
```

mark_deleted(b::Backend, v::SurfaceEllipticArc)

mark_deleted(b::Backend, v::LoftCurvePoint)

```
mark_deleted(b::Backend, v::Cylinder)
```

mark_deleted(b::Backend, v::ParametricSurface)

mark_deleted(b::Backend, v::SurfacePolygon)

```
mark_deleted(b::Backend, v::Scale)
```

mark_deleted(b::Backend, v::SurfaceEllipse)

mark_deleted(b::Backend, v::SubtractionShape2D)

mark_deleted(b::Backend, v::RegularPolygon)

mark_deleted(b::Backend, v::SurfaceGrid)

mark_deleted(b::Backend, v::RegularPyramid)

```
mark_deleted(b::Backend, v::Box)
```

mark_deleted(b::Backend, v::SurfaceRectangle)

```
mark_deleted(b::Backend, v::Circle)
```
```
mark_deleted(b::Backend, v::Thicken)
```
```
mark_deleted(b::Backend, v::Slice)
```
```
mark_deleted(b::Backend, v::Arc)
```
```
mark_deleted(b::Backend, v::Prism)
```

mark_deleted(b::Backend, v::BlockInstance)

mark_deleted(b::Backend, v::RegularPrism)

```
mark_deleted(b::Backend, v::Pyramid)
```
```
mark_deleted(b::Backend, v::UnionShape)
```
```
mark_deleted(b::Backend, v::Torus)
```
```
mark_deleted(b::Backend, v::Block)
```

mark_deleted(b::Backend, v::SubtractionShape3D)

```
mark_deleted(b::Backend, v::SurfaceArc)
```

mark_deleted(b::Backend, v::RevolveCurve)

```
mark_deleted(b::Backend, v::Point)
```
```
mark_deleted(b::Backend, v::Roof)
```
```
mark_deleted(b::Backend, v::Line)
```

mark_deleted(b::Backend, v::SurfaceRegularPolygon)

```
mark_deleted(b::Backend, v::Extrusion)
```

mark_deleted(b::Backend, v::RightCuboid)

```
mark_deleted(b::Backend, v::Ieslight)
```
```
mark_deleted(b::Backend, v::Column)
```
```
mark_deleted(b::Backend, v::FreeColumn)
```
```
mark_deleted(b::Backend, v::Chair)
```
```
mark_deleted(b::Backend, v::ClosedLine)
```

mark_deleted(b::Backend, v::LoftSurfacePoint)

```
mark_deleted(b::Backend, v::Spotlight)
```

mark_deleted(b::Backend, v::KhepriBase.Text)

```
mark_deleted(b::Backend, v::Dimension)
```
```
mark_deleted(b::Backend, v::SweepPath)
```
```
mark_deleted(b::Backend, v::Beam)
```
```
mark_deleted(b::Backend, v::Unknown)
```
```
mark_deleted(b::Backend, v::LoftPoints)
```
```
mark_deleted(b::Backend, v::Window)
```
```
mark_deleted(b::Backend, v::Cone)
```
```
mark_deleted(b::Backend, v::Material)
```
```
mark_deleted(b::Backend, v::EmptyShape)
```

mark_deleted(b::Backend, v::SurfaceCircle)

mark_deleted(b::Backend, v::CurtainWall)

mark_deleted(b::Backend, v::SurfaceMesh)

mark_deleted(b::Backend, v::ConeFrustum)

mark_deleted(b::Backend, v::EllipticArc)

```
mark_deleted(b::Backend, v::TrussBar)
```
```
mark_deleted(b::Backend, v::Slab)
```
```
mark_deleted(b::Backend, v::Level)
```

mark_deleted(b::Backend, v::ClosedSpline)

```
mark_deleted(b::Backend, v::LoftCurves)
```

mark_deleted(b::Backend, v::RegularPyramidFrustum)

mark_deleted(b::Backend, v::RevolvePoint)

mark_deleted(b::Backend, s::KhepriBase.Proxy)

```
mark_deleted(b::Backend, s)
```

material

```
material()
```
```
material(name::String)
```

material(name::String, color::RGB, bvs...)

```
material(layer)
```
```
material(layer, data; layer, data, ref)
```

material_data

```
material_data(v::Material)
```

material_layer

```
material_layer(v::Material)
```

material_ref

```
material_ref(b::Backend, m::Material)
```
```
material_ref(b::Backend, s::Shape)
```

material_refs

```
material_refs(b::Backend, materials)
```

max_displacement

```
max_displacement(results)
```
```
max_displacement(results, b::Backend)
```

max_loc

```
max_loc(p::Loc, q::Loc)
```

maybe_merged_bar

maybe_merged_bar(b::Backend, s::TrussBar)

maybe_merged_node

maybe_merged_node(b::Backend, s::TrussNode)

mentalray_render_view

```
mentalray_render_view(name::String)
```

mesh

```
mesh()
```
```
mesh(vertices::Vector{<:Loc})
```

mesh(vertices::Vector{<:Loc}, faces::Vector{Vector{Int64}})

meta_program

```
meta_program(p::Loc)
```
```
meta_program(v::Vec)
```
```
meta_program(x::Vector)
```
```
meta_program(v::Table)
```
```
meta_program(v::Mirror)
```
```
meta_program(v::Rotate)
```
```
meta_program(v::Ellipse)
```
```
meta_program(v::TableAndChairs)
```
```
meta_program(v::BeamFamily)
```
```
meta_program(v::Polygon)
```
```
meta_program(v::Move)
```
```
meta_program(v::Sweep)
```
```
meta_program(v::TrussNode)
```
```
meta_program(v::Pointlight)
```
```
meta_program(v::Spline)
```
```
meta_program(v::Isosurface)
```

meta_program(v::Parameter{WindowFamily})

```
meta_program(v::DoorFamily)
```
```
meta_program(v::Transform)
```
```
meta_program(v::SurfacePath)
```
```
meta_program(v::UniversalShape)
```
```
meta_program(v::Layer)
```
```
meta_program(v::WindowFamily)
```
```
meta_program(v::Parameter{ChairFamily})
```
```
meta_program(v::Panel)
```
```
meta_program(v::TableFamily)
```
```
meta_program(v::Door)
```
```
meta_program(v::LoftSurfaces)
```
```
meta_program(v::PyramidFrustum)
```
```
meta_program(v::Wall)
```
```
meta_program(v::Sphere)
```
```
meta_program(v::TableChairFamily)
```
```
meta_program(v::Parameter{BeamFamily})
```
```
meta_program(v::Parameter{PanelFamily})
```
```
meta_program(v::RevolveSurface)
```
```
meta_program(v::UnionMirror)
```
```
meta_program(v::Cuboid)
```
```
meta_program(v::Surface)
```
```
meta_program(v::IntersectionShape)
```
```
meta_program(v::Rectangle)
```
```
meta_program(v::LoftCurvePoint)
```
```
meta_program(v::SurfaceEllipticArc)
```
```
meta_program(v::Cylinder)
```
```
meta_program(v::ParametricSurface)
```
```
meta_program(v::SurfacePolygon)
```
```
meta_program(v::Scale)
```
```
meta_program(v::SurfaceEllipse)
```
```
meta_program(v::SubtractionShape2D)
```

meta_program(v::Parameter{CurtainWallFamily})

```
meta_program(v::RegularPolygon)
```
```
meta_program(v::SurfaceGrid)
```
```
meta_program(v::RegularPyramid)
```
```
meta_program(v::Box)
```
```
meta_program(v::SurfaceRectangle)
```
```
meta_program(v::Circle)
```
```
meta_program(v::Thicken)
```
```
meta_program(v::Slice)
```
```
meta_program(v::Arc)
```
```
meta_program(v::Prism)
```
```
meta_program(v::BlockInstance)
```
```
meta_program(v::RegularPrism)
```
```
meta_program(x::Bool)
```
```
meta_program(x::Real)
```
```
meta_program(v::Pyramid)
```
```
meta_program(v::Parameter{RoofFamily})
```
```
meta_program(v::Parameter{DoorFamily})
```
```
meta_program(v::UnionShape)
```
```
meta_program(v::TrussNodeFamily)
```
```
meta_program(v::Torus)
```
```
meta_program(v::Block)
```
```
meta_program(v::SubtractionShape3D)
```
```
meta_program(v::SurfaceArc)
```
```
meta_program(v::RevolveCurve)
```
```
meta_program(v::Point)
```

meta_program(v::Parameter{TrussNodeFamily})

```
meta_program(v::Parameter{TableFamily})
```
```
meta_program(v::ChairFamily)
```
```
meta_program(v::Roof)
```
```
meta_program(v::Parameter{SlabFamily})
```
```
meta_program(v::Line)
```
```
meta_program(v::WallFamily)
```
```
meta_program(v::RoofFamily)
```
```
meta_program(v::SurfaceRegularPolygon)
```
```
meta_program(v::SlabFamily)
```
```
meta_program(v::Extrusion)
```
```
meta_program(v::RightCuboid)
```
```
meta_program(v::Ieslight)
```
```
meta_program(v::Column)
```
```
meta_program(v::FreeColumn)
```
```
meta_program(v::Spotlight)
```
```
meta_program(v::Chair)
```
```
meta_program(v::CurtainWallFrameFamily)
```
```
meta_program(v::Parameter{WallFamily})
```
```
meta_program(v::ClosedLine)
```
```
meta_program(v::LoftSurfacePoint)
```
```
meta_program(v::PanelFamily)
```
```
meta_program(v::KhepriBase.Text)
```
```
meta_program(v::Dimension)
```
```
meta_program(v::SweepPath)
```

meta_program(v::Parameter{ColumnFamily})

```
meta_program(v::Beam)
```
```
meta_program(v::Unknown)
```
```
meta_program(v::LoftPoints)
```
```
meta_program(v::TrussBarFamily)
```
```
meta_program(v::Window)
```
```
meta_program(v::Cone)
```
```
meta_program(v::Material)
```
```
meta_program(v::EmptyShape)
```

meta_program(v::Parameter{TableChairFamily})

meta_program(v::Parameter{CurtainWallFrameFamily})

```
meta_program(v::SurfaceCircle)
```

meta_program(v::Parameter{TrussBarFamily})

```
meta_program(v::CurtainWall)
```
```
meta_program(v::SurfaceMesh)
```
```
meta_program(v::ConeFrustum)
```
```
meta_program(v::EllipticArc)
```
```
meta_program(v::TrussBar)
```
```
meta_program(v::ColumnFamily)
```
```
meta_program(v::CurtainWallFamily)
```
```
meta_program(v::Slab)
```
```
meta_program(v::Level)
```
```
meta_program(v::LoftCurves)
```
```
meta_program(p::OpenPolygonalPath)
```
```
meta_program(v::ClosedSpline)
```
```
meta_program(v::Annulus)
```
```
meta_program(v::RegularPyramidFrustum)
```
```
meta_program(v::RevolvePoint)
```
```
meta_program(x)
```

min_loc

```
min_loc(p::Loc, q::Loc)
```

mirror

```
mirror()
```
```
mirror(shape)
```
```
mirror(shape, p)
```
```
mirror(shape, p, n; shape, p, n, ref)
```

mirror_n

```
mirror_n(v::Mirror)
```

mirror_p

```
mirror_p(v::Mirror)
```

mirror_shape

```
mirror_shape(v::Mirror)
```

mirrored_on_x

```
mirrored_on_x(path::OpenPolygonalPath)
```

mirrored_on_y

```
mirrored_on_y(path::OpenPolygonalPath)
```

mirrored_on_z

```
mirrored_on_z(path::OpenPolygonalPath)
```

mirrored_path

mirrored_path(path::Path, p::Loc, v::Vec)

move

```
move()
```
```
move(shape)
```
```
move(shape, v; shape, v, ref)
```

move_shape

```
move_shape(v::Move)
```

move_v

```
move_v(v::Move)
```

name

```
name(b::Backend)
```

nearest_point_from_lines

nearest_point_from_lines(l0p0::Loc, l0p1::Loc, l1p0::Loc, l1p1::Loc)

new_backend

```
new_backend()
```
```
new_backend(b::Backend)
```

node_displacement_function

```
node_displacement_function(res)
```

node_displacement_function(res, backend::Backend; backend)

norm

norm(v::Union{LinearAlgebra.Adjoint{T, <:AbstractVector} where T, LinearAlgebra.Transpose{T, <:AbstractVector} where T}, p::Real)

norm(x::Union{SparseArrays.SparseVector{Tv, Ti}, SubArray{Tv, 1, <:SparseArrays.AbstractSparseMatrixCSC{Tv, Ti}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, false}, SubArray{Tv, 1, <:SparseArrays.AbstractSparseVector{Tv, Ti}, Tuple{Base.Slice{Base.OneTo{Int64}}}, false}} where {Tv, Ti})

norm(x::StridedVector{T}, rx::Union{AbstractRange{TI}, UnitRange{TI}}) where {T<:Union{Float32, Float64, ComplexF32, ComplexF64}, TI<:Integer}

norm(x::Union{SparseArrays.SparseVector{Tv, Ti}, SubArray{Tv, 1, <:SparseArrays.AbstractSparseMatrixCSC{Tv, Ti}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, false}, SubArray{Tv, 1, <:SparseArrays.AbstractSparseVector{Tv, Ti}, Tuple{Base.Slice{Base.OneTo{Int64}}}, false}} where {Tv, Ti}, p::Real)

```
norm(v::Vec)
```

norm(A::SparseArrays.AbstractSparseMatrixCSC)

norm(A::SparseArrays.AbstractSparseMatrixCSC, p::Real)

```
norm(x::Number)
```
```
norm(x::Number, p::Real)
```
```
norm(a::StaticArraysCore.StaticArray)
```

norm(a::StaticArraysCore.StaticArray, p::Real)

```
norm(::Missing)
```
```
norm(::Missing, p::Real)
```
```
norm(itr)
```
```
norm(itr, p::Real)
```

offset

```
offset(path, d::Real)
```

on_change

```
on_change(f, shape::Shape)
```
```
on_change(f, shapes)
```

open_path_ops

```
open_path_ops(start, ops...)
```

open_path_sequence

```
open_path_sequence(paths...)
```

open_polygonal_path

```
open_polygonal_path()
```
```
open_polygonal_path(vertices)
```

open_spline_path

```
open_spline_path()
```
```
open_spline_path(vertices)
```
```
open_spline_path(vertices, v0)
```
```
open_spline_path(vertices, v0, v1)
```

outer_path

```
outer_path(region::Region)
```

panel

```
panel()
```
```
panel(region)
```

panel(region, family; region, family, ref)

panel_family

```
panel_family()
```
```
panel_family(Name::String)
```

panel_family(Name::String, Thickness::Real)

panel_family(Name::String, Thickness::Real, Right_material::Material)

panel_family(Name::String, Thickness::Real, Right_material::Material, Left_material::Material)

panel_family(Name::String, Thickness::Real, Right_material::Material, Left_material::Material, Side_material::Material; name, thickness, right_material, left_material, side_material, based_on, implemented_as, data)

```
panel_family(v::Panel)
```

panel_family_element

```
panel_family_element(family::Family)
```

panel_family_element(family::Family, implemented_as; name, thickness, right_material, left_material, side_material)

panel_region

```
panel_region(v::Panel)
```

panning

```
panning(camera, targets)
```
```
panning(camera, targets, lens)
```

panning(camera, targets, lens, aperture)

parametric_surface

```
parametric_surface()
```
```
parametric_surface(definition)
```

parametric_surface(definition, domain_u)

parametric_surface(definition, domain_u, domain_v; definition, domain_u, domain_v, ref)

parametric_surface_definition

parametric_surface_definition(v::ParametricSurface)

parametric_surface_domain_u

parametric_surface_domain_u(v::ParametricSurface)

parametric_surface_domain_v

parametric_surface_domain_v(v::ParametricSurface)

parse_signature

parse_signature(::Val{:CPP}, sig::AbstractString)

parse_signature(::Val{:CS}, sig::AbstractString)

parse_signature(::Val{:PY}, sig::AbstractString)

parse_signature(::Val{:ACAD}, sig::T) where T

path_domain

path_domain(path::Union{ClosedPolygonalPath, OpenPolygonalPath})

```
path_domain(path::ArcPath)
```
```
path_domain(path::CircularPath)
```
```
path_domain(path::RectangularPath)
```
```
path_domain(path::Path)
```

path_end

```
path_end(path::OpenPolygonalPath)
```
```
path_end(path::OpenSplinePath)
```
```
path_end(path::ClosedSplinePath)
```
```
path_end(path::ClosedPath)
```
```
path_end(p::Path)
```

path_frames

```
path_frames(path::RectangularPath)
```
```
path_frames(path::OpenPolygonalPath)
```
```
path_frames(path::ClosedPolygonalPath)
```
```
path_frames(path::Path)
```

path_length

```
path_length(ps::Vector{<:Loc})
```

path_length(path::Union{ClosedPathSequence, OpenPathSequence})

```
path_length(path::CircularPath)
```
```
path_length(path::ArcPath)
```
```
path_length(path::RectangularPath)
```
```
path_length(path::OpenPolygonalPath)
```
```
path_length(path::ClosedPolygonalPath)
```
```
path_length(path::KhepriBase.PathOps)
```
```
path_length(op::LineOp)
```
```
path_length(op::ArcOp)
```

path_replace_suffix

path_replace_suffix(path::String, suffix::String)

path_sequence

```
path_sequence(paths...)
```

path_set

```
path_set(paths...)
```

path_start

path_start(path::Union{ClosedPolygonalPath, OpenPolygonalPath})

path_start(path::Union{ClosedSplinePath, OpenSplinePath})

```
path_start(p::Path)
```

path_vertices

path_vertices(path::Union{ClosedPolygonalPath, ClosedSplinePath, OpenPolygonalPath, OpenSplinePath})

```
path_vertices(path::Path)
```
```
path_vertices(s::Shape1D)
```

path_vertices_on

```
path_vertices_on(path::Path, p)
```
```
path_vertices_on(vs::Vector{<:Loc}, p)
```

planar_path_normal

planar_path_normal(path::Union{ClosedPolygonalPath, OpenPolygonalPath})

planar_path_normal(path::T) where T<:Union{ClosedPathSequence, OpenPathSequence, PathSet, Region}

```
planar_path_normal(path::ArcPath)
```
```
planar_path_normal(path::CircularPath)
```

planar_path_normal(path::RectangularPath)

planar_polygonal_path

```
planar_polygonal_path(path)
```

plus_profile

```
plus_profile()
```
```
plus_profile(Width::Real)
```

plus_profile(Width::Real, Height::Real; width, height, thickness)

point

```
point()
```
```
point(position)
```

point(position, material; position, material, ref)

point_material

```
point_material(v::Point)
```

point_position

```
point_position(v::Point)
```

pointlight

```
pointlight()
```
```
pointlight(loc)
```
```
pointlight(loc, color)
```
```
pointlight(loc, color, intensity)
```

pointlight(loc, color, intensity, range)

pointlight(loc, color, intensity, range, level; loc, color, intensity, range, level, ref)

pointlight_color

```
pointlight_color(v::Pointlight)
```

pointlight_intensity

```
pointlight_intensity(v::Pointlight)
```

pointlight_level

```
pointlight_level(v::Pointlight)
```

pointlight_loc

```
pointlight_loc(v::Pointlight)
```

pointlight_range

```
pointlight_range(v::Pointlight)
```

pol

```
pol(rho::Real, phi::Real)
```

pol(rho::Real, phi::Real, cs::KhepriBase.CS)

cyl_phi

```
cyl_phi(p::Union{Loc, Vec})
```

cyl_rho

```
cyl_rho(p::Union{Loc, Vec})
```

polygon

```
polygon()
```
```
polygon(vertices)
```

polygon(vertices, material; vertices, material, ref)

```
polygon(v0, v1, vs...)
```

polygon_material

```
polygon_material(v::Polygon)
```

polygon_vertices

```
polygon_vertices(v::Polygon)
```

polygonal_path

```
polygonal_path()
```
```
polygonal_path(vertices::Vector{<:Loc})
```
```
polygonal_path(v::Loc, vs...)
```

prepare_for_saving_file

```
prepare_for_saving_file(path::String)
```

prism

```
prism()
```
```
prism(bs::Vector{<:Loc}, h::Real)
```
```
prism(bs)
```
```
prism(bs, v)
```

prism(bs, v, material; bs, v, material, ref)

prism_bs

```
prism_bs(v::Prism)
```

prism_material

```
prism_material(v::Prism)
```

prism_v

```
prism_v(v::Prism)
```

process_bars

```
process_bars(bars, processed_nodes)
```

process_nodes

```
process_nodes(nodes)
```
```
process_nodes(nodes, load)
```

process_nodes(nodes, load, loads_points)

pyramid

```
pyramid()
```
```
pyramid(bs)
```
```
pyramid(bs, t)
```

pyramid(bs, t, material; bs, t, material, ref)

pyramid_bs

```
pyramid_bs(v::Pyramid)
```

pyramid_frustum

```
pyramid_frustum()
```
```
pyramid_frustum(bs)
```
```
pyramid_frustum(bs, ts)
```

pyramid_frustum(bs, ts, material; bs, ts, material, ref)

pyramid_frustum_bs

```
pyramid_frustum_bs(v::PyramidFrustum)
```

pyramid_frustum_material

pyramid_frustum_material(v::PyramidFrustum)

pyramid_frustum_ts

```
pyramid_frustum_ts(v::PyramidFrustum)
```

pyramid_material

```
pyramid_material(v::Pyramid)
```

pyramid_t

```
pyramid_t(v::Pyramid)
```

quad_center

```
quad_center(p0, p1, p2, p3)
```

quad_grid

quad_grid(quad, points, closed_u, closed_v)

quad_grid_indexes

quad_grid_indexes(si, sj, closed_u, closed_v)

quad_normal

```
quad_normal(p0, p1, p2, p3)
```

random

```
random(x::Int64)
```
```
random(x::Real)
```

random_range

```
random_range(x0, x1)
```

raw_plane

```
raw_plane(v::XYZ)
```

raw_point

```
raw_point(v::Union{VXYZ, XYZ})
```

realistic_sky

```
realistic_sky()
```
```
realistic_sky(date::Dates.DateTime)
```

realistic_sky(date::Dates.DateTime, latitude::Real)

realistic_sky(date::Dates.DateTime, latitude::Real, longitude::Real)

realistic_sky(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real)

realistic_sky(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real, meridian::Real)

realistic_sky(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real, meridian::Real, turbidity::Real)

realistic_sky(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real, meridian::Real, turbidity::Real, sun::Bool)

realistic_sky(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real, meridian::Real, turbidity::Real, sun::Bool, backends::Tuple{Vararg{Backend}}; date, latitude, longitude, elevation, meridian, turbidity, sun, backends)

realize

realize(b::Backend, s::Union{SubtractionShape2D, SubtractionShape3D})

realize(b::Backend, s::Union{Door, Window})

```
realize(b::Backend, s::Table)
```
```
realize(b::Backend, s::Pyramid)
```
```
realize(b::Backend, s::TableAndChairs)
```
```
realize(b::Backend, s::UnionShape)
```
```
realize(b::Backend, s::Polygon)
```
```
realize(b::Backend, s::Sweep)
```
```
realize(b::Backend, s::Torus)
```
```
realize(b::Backend, s::TrussNode)
```
```
realize(b::Backend, s::Pointlight)
```
```
realize(b::Backend, s::Spline)
```
```
realize(b::Backend, s::Isosurface)
```
```
realize(b::Backend, s::RevolveCurve)
```
```
realize(b::Backend, s::SurfaceArc)
```
```
realize(b::Backend, s::SurfacePath)
```
```
realize(b::Backend, l::Layer)
```
```
realize(b::Backend, s::Point)
```
```
realize(b::Backend, s::Panel)
```
```
realize(b::Backend, s::Roof)
```
```
realize(b::Backend, s::Line)
```
```
realize(b::Backend, s::LoftSurfaces)
```

realize(b::Backend, s::SurfaceRegularPolygon)

```
realize(b::Backend, s::PyramidFrustum)
```
```
realize(b::Backend, s::Ieslight)
```
```
realize(b::B, w::Wall) where B<:Backend
```
```
realize(b::Backend, s::Extrusion)
```
```
realize(b::Backend, s::Sphere)
```
```
realize(b::Backend, s::RightCuboid)
```
```
realize(b::Backend, s::Chair)
```
```
realize(b::Backend, s::Column)
```
```
realize(b::Backend, s::FreeColumn)
```
```
realize(b::Backend, s::RevolveSurface)
```

realize(b::Backend, s::LoftSurfacePoint)

```
realize(b::Backend, s::Cuboid)
```
```
realize(b::Backend, s::Surface)
```
```
realize(b::Backend, s::Rectangle)
```
```
realize(b::Backend, s::ClosedLine)
```

realize(b::Backend, s::SurfaceEllipticArc)

```
realize(b::Backend, s::LoftCurvePoint)
```
```
realize(b::Backend, s::Spotlight)
```
```
realize(b::Backend, s::KhepriBase.Text)
```
```
realize(b::Backend, s::Dimension)
```
```
realize(b::Backend, s::Cylinder)
```
```
realize(b::Backend, s::SurfacePolygon)
```
```
realize(b::Backend, s::Beam)
```
```
realize(b::Backend, s::LoftPoints)
```
```
realize(b::Backend, s::Cone)
```
```
realize(b::Backend, m::Material)
```
```
realize(b::Backend, s::RegularPolygon)
```
```
realize(b::Backend, s::SurfaceGrid)
```
```
realize(b::Backend, s::SurfaceCircle)
```
```
realize(b::Backend, s::RegularPyramid)
```
```
realize(b::Backend, s::Box)
```
```
realize(b::Backend, s::CurtainWall)
```
```
realize(b::Backend, s::SurfaceMesh)
```
```
realize(b::Backend, s::ConeFrustum)
```

realize(b::Backend, s::SurfaceRectangle)

```
realize(b::Backend, s::Circle)
```
```
realize(b::Backend, s::TrussBar)
```
```
realize(b::Backend, s::Arc)
```
```
realize(b::Backend, s::Slab)
```
```
realize(b::Backend, s::Prism)
```
```
realize(b::Backend, s::Level)
```
```
realize(b::Backend, s::LoftCurves)
```
```
realize(b::Backend, s::ClosedSpline)
```
```
realize(b::Backend, s::RevolvePoint)
```

realize(b::Backend, s::RegularPyramidFrustum)

```
realize(b::Backend, s::RegularPrism)
```

realize(::HasBooleanOps{false}, b::Backend, w::Wall)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::EmptyShape)

```
realize(b::Backend, s::EmptyShape)
```

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Mirror)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Rotate)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::IntersectionShape)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Ellipse)

```
realize(b::Backend, s::Ellipse)
```

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::UnionMirror)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, f::ChairFamily)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Move)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, f::TableFamily)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Scale)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::SurfaceEllipse)

```
realize(b::Backend, s::SurfaceEllipse)
```

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::EllipticArc)

```
realize(b::Backend, s::EllipticArc)
```

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Thicken)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Slice)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Unknown)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Block)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::Transform)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, f::TableChairFamily)

```
realize(b::Backend, f::Family)
```

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::BlockInstance)

realize(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, s::UniversalShape)

```
realize(b::Backend, s::UniversalShape)
```

realize(::HasBooleanOps{true}, b::Backend, w::Wall)

realize_beam_profile

realize_beam_profile(s::KhepriBase.BIMShape, profile::Path, cb::Loc, length::Real)

realize_beam_profile(s::KhepriBase.BIMShape, profile::Path, cb::Loc, length::Real, backends::Tuple{Vararg{Backend}}; backends)

realize_shapes

```
realize_shapes(b::IOBufferBackend)
```

rectangle

```
rectangle()
```
```
rectangle(p::Loc, q::Loc)
```
```
rectangle(corner)
```
```
rectangle(corner, dx)
```
```
rectangle(corner, dx, dy)
```

rectangle(corner, dx, dy, material; corner, dx, dy, material, ref)

rectangle_corner

```
rectangle_corner(v::Rectangle)
```

rectangle_dx

```
rectangle_dx(v::Rectangle)
```

rectangle_dy

```
rectangle_dy(v::Rectangle)
```

rectangle_material

```
rectangle_material(v::Rectangle)
```

rectangular_path

```
rectangular_path()
```
```
rectangular_path(corner::Loc)
```
```
rectangular_path(corner::Loc, dx::Real)
```

rectangular_path(corner::Loc, dx::Real, dy::Real)

rectangular_profile

```
rectangular_profile()
```
```
rectangular_profile(Width::Real)
```

rectangular_profile(Width::Real, Height::Real; width, height)

ref

```
ref(b::Backend)
```
```
ref(b::Backend, s::KhepriBase.Proxy)
```

region

```
region(r::Region, inners...)
```
```
region(outer, inners...)
```

register_for_changes

register_for_changes(shapes::Vector{<:Shape})

register_shape_for_changes

register_shape_for_changes(s::Shape, s::Shape)

register_shape_for_changes(s::Shape, s::Shape, b::Backend)

regular_polygon

```
regular_polygon()
```
```
regular_polygon(edges)
```
```
regular_polygon(edges, center)
```
```
regular_polygon(edges, center, radius)
```

regular_polygon(edges, center, radius, angle)

regular_polygon(edges, center, radius, angle, inscribed)

regular_polygon(edges, center, radius, angle, inscribed, material; edges, center, radius, angle, inscribed, material, ref)

regular_polygon_angle

regular_polygon_angle(v::RegularPolygon)

regular_polygon_center

regular_polygon_center(v::RegularPolygon)

regular_polygon_edges

regular_polygon_edges(v::RegularPolygon)

regular_polygon_inscribed

regular_polygon_inscribed(v::RegularPolygon)

regular_polygon_material

regular_polygon_material(v::RegularPolygon)

regular_polygon_radius

regular_polygon_radius(v::RegularPolygon)

regular_polygon_vertices

```
regular_polygon_vertices()
```

regular_polygon_vertices(edges::Integer)

regular_polygon_vertices(edges::Integer, center::Loc)

regular_polygon_vertices(edges::Integer, center::Loc, radius::Real)

regular_polygon_vertices(edges::Integer, center::Loc, radius::Real, angle::Real)

regular_polygon_vertices(edges::Integer, center::Loc, radius::Real, angle::Real, is_inscribed::Bool)

regular_prism

```
regular_prism()
```

regular_prism(edges::Integer, cb::Loc, r::Real, angle::Real, ct::Loc)

regular_prism(edges::Integer, cb::Loc, r::Real, angle::Real, ct::Loc, inscribed::Bool)

```
regular_prism(edges)
```
```
regular_prism(edges, cb)
```
```
regular_prism(edges, cb, r)
```
```
regular_prism(edges, cb, r, angle)
```
```
regular_prism(edges, cb, r, angle, h)
```

regular_prism(edges, cb, r, angle, h, inscribed)

regular_prism(edges, cb, r, angle, h, inscribed, material; edges, cb, r, angle, h, inscribed, material, ref)

regular_prism_angle

```
regular_prism_angle(v::RegularPrism)
```

regular_prism_cb

```
regular_prism_cb(v::RegularPrism)
```

regular_prism_edges

```
regular_prism_edges(v::RegularPrism)
```

regular_prism_h

```
regular_prism_h(v::RegularPrism)
```

regular_prism_inscribed

regular_prism_inscribed(v::RegularPrism)

regular_prism_material

```
regular_prism_material(v::RegularPrism)
```

regular_prism_r

```
regular_prism_r(v::RegularPrism)
```

regular_pyramid

```
regular_pyramid()
```

regular_pyramid(edges::Integer, cb::Loc, rb::Real, angle::Real, ct::Loc)

regular_pyramid(edges::Integer, cb::Loc, rb::Real, angle::Real, ct::Loc, inscribed::Bool)

```
regular_pyramid(edges)
```
```
regular_pyramid(edges, cb)
```
```
regular_pyramid(edges, cb, rb)
```
```
regular_pyramid(edges, cb, rb, angle)
```

regular_pyramid(edges, cb, rb, angle, h)

regular_pyramid(edges, cb, rb, angle, h, inscribed)

regular_pyramid(edges, cb, rb, angle, h, inscribed, material; edges, cb, rb, angle, h, inscribed, material, ref)

regular_pyramid_angle

regular_pyramid_angle(v::RegularPyramid)

regular_pyramid_cb

```
regular_pyramid_cb(v::RegularPyramid)
```

regular_pyramid_edges

regular_pyramid_edges(v::RegularPyramid)

regular_pyramid_frustum

```
regular_pyramid_frustum()
```

regular_pyramid_frustum(edges::Integer, cb::Loc, rb::Real, angle::Real, ct::Loc)

regular_pyramid_frustum(edges::Integer, cb::Loc, rb::Real, angle::Real, ct::Loc, rt::Real)

regular_pyramid_frustum(edges::Integer, cb::Loc, rb::Real, angle::Real, ct::Loc, rt::Real, inscribed::Bool)

```
regular_pyramid_frustum(edges)
```
```
regular_pyramid_frustum(edges, cb)
```
```
regular_pyramid_frustum(edges, cb, rb)
```

regular_pyramid_frustum(edges, cb, rb, angle)

regular_pyramid_frustum(edges, cb, rb, angle, h)

regular_pyramid_frustum(edges, cb, rb, angle, h, rt)

regular_pyramid_frustum(edges, cb, rb, angle, h, rt, inscribed)

regular_pyramid_frustum(edges, cb, rb, angle, h, rt, inscribed, material; edges, cb, rb, angle, h, rt, inscribed, material, ref)

regular_pyramid_frustum_angle

regular_pyramid_frustum_angle(v::RegularPyramidFrustum)

regular_pyramid_frustum_cb

regular_pyramid_frustum_cb(v::RegularPyramidFrustum)

regular_pyramid_frustum_edges

regular_pyramid_frustum_edges(v::RegularPyramidFrustum)

regular_pyramid_frustum_h

regular_pyramid_frustum_h(v::RegularPyramidFrustum)

regular_pyramid_frustum_inscribed

regular_pyramid_frustum_inscribed(v::RegularPyramidFrustum)

regular_pyramid_frustum_material

regular_pyramid_frustum_material(v::RegularPyramidFrustum)

regular_pyramid_frustum_rb

regular_pyramid_frustum_rb(v::RegularPyramidFrustum)

regular_pyramid_frustum_rt

regular_pyramid_frustum_rt(v::RegularPyramidFrustum)

regular_pyramid_h

```
regular_pyramid_h(v::RegularPyramid)
```

regular_pyramid_inscribed

regular_pyramid_inscribed(v::RegularPyramid)

regular_pyramid_material

regular_pyramid_material(v::RegularPyramid)

regular_pyramid_rb

```
regular_pyramid_rb(v::RegularPyramid)
```

remap

```
remap(in, ::Any, ::Any)
```

render_pathname

```
render_pathname(name::String)
```

render_size

```
render_size()
```

render_size(width::Integer, heigth::Integer)

render_view

```
render_view()
```
```
render_view(name::String)
```

render_view(name::String, backend::Backend)

rendering_with

rendering_with(f; dir, user_dir, backend_dir, kind_dir, color_dir, ext, width, height, quality, exposure, floor_width, floor_height)

reset_backend

```
reset_backend()
```
```
reset_backend(b::SocketBackend)
```

reset_backend(backend::Backend; backend)

retry_connecting

retry_connecting(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64})

```
retry_connecting(b::RemoteBackend)
```

reverse_dict

```
reverse_dict(dict)
```

revolve

```
revolve()
```
```
revolve(profile::Shape)
```
```
revolve(profile::Shape, p::Loc)
```
```
revolve(profile::Shape, p::Loc, n::Vec)
```

revolve(profile::Shape, p::Loc, n::Vec, start_angle::Real)

revolve(profile::Shape, p::Loc, n::Vec, start_angle::Real, amplitude::Real)

revolve_curve

```
revolve_curve()
```
```
revolve_curve(profile)
```
```
revolve_curve(profile, p)
```
```
revolve_curve(profile, p, n)
```

revolve_curve(profile, p, n, start_angle)

revolve_curve(profile, p, n, start_angle, amplitude)

revolve_curve(profile, p, n, start_angle, amplitude, material; profile, p, n, start_angle, amplitude, material, ref)

revolve_curve_amplitude

revolve_curve_amplitude(v::RevolveCurve)

revolve_curve_material

```
revolve_curve_material(v::RevolveCurve)
```

revolve_curve_n

```
revolve_curve_n(v::RevolveCurve)
```

revolve_curve_p

```
revolve_curve_p(v::RevolveCurve)
```

revolve_curve_profile

```
revolve_curve_profile(v::RevolveCurve)
```

revolve_curve_start_angle

revolve_curve_start_angle(v::RevolveCurve)

revolve_point

```
revolve_point()
```
```
revolve_point(profile)
```
```
revolve_point(profile, p)
```
```
revolve_point(profile, p, n)
```

revolve_point(profile, p, n, start_angle)

revolve_point(profile, p, n, start_angle, amplitude)

revolve_point(profile, p, n, start_angle, amplitude, material; profile, p, n, start_angle, amplitude, material, ref)

revolve_point_amplitude

revolve_point_amplitude(v::RevolvePoint)

revolve_point_material

```
revolve_point_material(v::RevolvePoint)
```

revolve_point_n

```
revolve_point_n(v::RevolvePoint)
```

revolve_point_p

```
revolve_point_p(v::RevolvePoint)
```

revolve_point_profile

```
revolve_point_profile(v::RevolvePoint)
```

revolve_point_start_angle

revolve_point_start_angle(v::RevolvePoint)

revolve_surface

```
revolve_surface()
```
```
revolve_surface(profile)
```
```
revolve_surface(profile, p)
```
```
revolve_surface(profile, p, n)
```

revolve_surface(profile, p, n, start_angle)

revolve_surface(profile, p, n, start_angle, amplitude)

revolve_surface(profile, p, n, start_angle, amplitude, material; profile, p, n, start_angle, amplitude, material, ref)

revolve_surface_amplitude

revolve_surface_amplitude(v::RevolveSurface)

revolve_surface_material

revolve_surface_material(v::RevolveSurface)

revolve_surface_n

```
revolve_surface_n(v::RevolveSurface)
```

revolve_surface_p

```
revolve_surface_p(v::RevolveSurface)
```

revolve_surface_profile

revolve_surface_profile(v::RevolveSurface)

revolve_surface_start_angle

revolve_surface_start_angle(v::RevolveSurface)

rgb_radiance

```
rgb_radiance(c::RGB)
```

right_cuboid

```
right_cuboid()
```

right_cuboid(cb::Loc, width::Real, height::Real, ct::Loc)

right_cuboid(cb::Loc, width::Real, height::Real, ct::Loc, angle::Real)

```
right_cuboid(cb)
```
```
right_cuboid(cb, width)
```
```
right_cuboid(cb, width, height)
```
```
right_cuboid(cb, width, height, h)
```

right_cuboid(cb, width, height, h, material; cb, width, height, h, material, ref)

right_cuboid_cb

```
right_cuboid_cb(v::RightCuboid)
```

right_cuboid_h

```
right_cuboid_h(v::RightCuboid)
```

right_cuboid_height

```
right_cuboid_height(v::RightCuboid)
```

right_cuboid_material

```
right_cuboid_material(v::RightCuboid)
```

right_cuboid_width

```
right_cuboid_width(v::RightCuboid)
```

roof

```
roof()
```
```
roof(region)
```
```
roof(region, level)
```

roof(region, level, family; region, level, family, ref)

roof_family

```
roof_family()
```
```
roof_family(Name::String)
```

roof_family(Name::String, Thickness::Real)

roof_family(Name::String, Thickness::Real, Coating_thickness::Real)

roof_family(Name::String, Thickness::Real, Coating_thickness::Real, Bottom_material::Material)

roof_family(Name::String, Thickness::Real, Coating_thickness::Real, Bottom_material::Material, Top_material::Material)

roof_family(Name::String, Thickness::Real, Coating_thickness::Real, Bottom_material::Material, Top_material::Material, Side_material::Material; name, thickness, coating_thickness, bottom_material, top_material, side_material, based_on, implemented_as, data)

```
roof_family(v::Roof)
```

roof_family_element

```
roof_family_element(family::Family)
```

roof_family_element(family::Family, implemented_as; name, thickness, coating_thickness, bottom_material, top_material, side_material)

roof_level

```
roof_level(v::Roof)
```

roof_region

```
roof_region(v::Roof)
```

rotate

```
rotate()
```
```
rotate(shape)
```
```
rotate(shape, angle)
```
```
rotate(shape, angle, p)
```

rotate(shape, angle, p, v; shape, angle, p, v, ref)

rotate_angle

```
rotate_angle(v::Rotate)
```

rotate_p

```
rotate_p(v::Rotate)
```

rotate_shape

```
rotate_shape(v::Rotate)
```

rotate_v

```
rotate_v(v::Rotate)
```

rotate_vector

```
rotate_vector(vector, axis, angle)
```

rotated_around_p_v_cs

rotated_around_p_v_cs(cs::KhepriBase.CS, a::Real, b::Real, c::Real, u::Real, v::Real, w::Real, phi::Real)

rotated_x_cs

rotated_x_cs(cs::KhepriBase.CS, α::Real)

rotated_y_cs

rotated_y_cs(cs::KhepriBase.CS, α::Real)

rotated_z_cs

rotated_z_cs(cs::KhepriBase.CS, α::Real)

rotated_zyx_cs

rotated_zyx_cs(cs::KhepriBase.CS, x::Real, y::Real, z::Real)

rotation_minimizing_frames

```
rotation_minimizing_frames(frames)
```
```
rotation_minimizing_frames(u0, xs, ts)
```

save_as

save_as(pathname::String, format::String)

save_as(pathname::String, format::String, backend::Backend; backend)

save_film_frame

```
save_film_frame()
```
```
save_film_frame(obj; backend)
```

save_shape!

save_shape!(b::IOBufferBackend, s::Shape)

```
save_shape!(b::Backend, s::Shape)
```

save_view

```
save_view()
```
```
save_view(name::String)
```

scale

```
scale()
```
```
scale(path::CircularPath, s::Real)
```

scale(path::CircularPath, s::Real, p::Loc)

```
scale(path::RectangularPath, s::Real)
```

scale(path::RectangularPath, s::Real, p::Loc)

```
scale(path::OpenPolygonalPath, s::Real)
```

scale(path::OpenPolygonalPath, s::Real, p::Loc)

scale(path::ClosedPolygonalPath, s::Real)

scale(path::ClosedPolygonalPath, s::Real, p::Loc)

```
scale(shape)
```
```
scale(shape, s)
```
```
scale(shape, s, p; shape, s, p, ref)
```

scale_p

```
scale_p(v::Scale)
```

scale_s

```
scale_s(v::Scale)
```

scale_shape

```
scale_shape(v::Scale)
```

scaled_cs

scaled_cs(cs::KhepriBase.CS, x::Real, y::Real, z::Real)

scaled_cs(p::XYZ, x::Real, y::Real, z::Real)

select_camera_target_lens_positions

```
select_camera_target_lens_positions()
```

select_curve

```
select_curve()
```
```
select_curve(prompt::String)
```

select_curve(prompt::String, backend::Backend; prompt, backend)

select_curves

```
select_curves()
```
```
select_curves(prompt::String)
```

select_curves(prompt::String, backend::Backend; prompt, backend)

select_many_with_prompt

select_many_with_prompt(prompt::String, b::Backend, f::Function)

select_one_with_prompt

select_one_with_prompt(prompt::String, b::Backend, f::Function)

select_point

```
select_point()
```
```
select_point(prompt::String)
```

select_point(prompt::String, backend::Backend; prompt, backend)

select_points

```
select_points()
```
```
select_points(prompt::String)
```

select_points(prompt::String, backend::Backend; prompt, backend)

select_position

```
select_position()
```
```
select_position(prompt::String)
```

select_position(prompt::String, backend::Backend; prompt, backend)

select_positions

```
select_positions()
```
```
select_positions(prompt::String)
```

select_positions(prompt::String, backend::Backend; prompt, backend)

select_shape

```
select_shape()
```
```
select_shape(prompt::String)
```

select_shape(prompt::String, backend::Backend; prompt, backend)

select_shapes

```
select_shapes()
```
```
select_shapes(prompt::String)
```

select_shapes(prompt::String, backend::Backend; prompt, backend)

select_solid

```
select_solid()
```
```
select_solid(prompt::String)
```

select_solid(prompt::String, backend::Backend; prompt, backend)

select_solids

```
select_solids()
```
```
select_solids(prompt::String)
```

select_solids(prompt::String, backend::Backend; prompt, backend)

select_surface

```
select_surface()
```
```
select_surface(prompt::String)
```

select_surface(prompt::String, backend::Backend; prompt, backend)

select_surfaces

```
select_surfaces()
```
```
select_surfaces(prompt::String)
```

select_surfaces(prompt::String, backend::Backend; prompt, backend)

series

series(start::Real, step::Real, count::Int64)

set_backend_family

set_backend_family(family::Family, backend::Backend, backend_family::Family)

set_on!

```
set_on!(b::Backend, proxy, ref)
```
```
set_on!(proxy, ref)
```

set_ground

```
set_ground()
```
```
set_ground(level::Real)
```

set_ground(level::Real, material::Material)

set_ground(level::Real, material::Material, backends::Tuple{Vararg{Backend}}; level, material, backends)

set_layer_active

```
set_layer_active(layer, status)
```

set_layer_active(layer, status, backends::Tuple{Vararg{Backend}}; backends)

set_length_unit

```
set_length_unit()
```
```
set_length_unit(unit::String)
```

set_length_unit(unit::String, backends::Tuple{Vararg{Backend}}; unit, backends)

set_on!

```
set_on!(b::Backend, proxy, ref)
```
```
set_on!(proxy, ref)
```

set_normal_sky

```
set_normal_sky()
```

set_normal_sky(backends::Tuple{Vararg{Backend}}; backends)

set_on!

```
set_on!(b::Backend, proxy, ref)
```
```
set_on!(proxy, ref)
```

set_overcast_sky

```
set_overcast_sky()
```

set_overcast_sky(backends::Tuple{Vararg{Backend}}; backends)

set_random_seed

```
set_random_seed(v::Int64)
```

set_sky

```
set_sky()
```
```
set_sky(turbidity::Real)
```
```
set_sky(turbidity::Real, sun::Bool)
```

set_sky(turbidity::Real, sun::Bool, backends::Tuple{Vararg{Backend}}; turbidity, sun, backends)

set_time_place

```
set_time_place()
```
```
set_time_place(date::Dates.DateTime)
```

set_time_place(date::Dates.DateTime, latitude::Real)

set_time_place(date::Dates.DateTime, latitude::Real, longitude::Real)

set_time_place(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real)

set_time_place(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real, meridian::Real)

set_time_place(date::Dates.DateTime, latitude::Real, longitude::Real, elevation::Real, meridian::Real, backends::Tuple{Vararg{Backend}}; date, latitude, longitude, elevation, meridian, backends)

set_view

```
set_view(camera::Loc, target::Loc)
```

set_view(camera::Loc, target::Loc, lens::Real)

set_view(camera::Loc, target::Loc, lens::Real, aperture::Real)

set_view(camera::Loc, target::Loc, lens::Real, aperture::Real, backends::Tuple{Vararg{Backend}}; lens, aperture, backends)

set_view_save_frame

```
set_view_save_frame(camera, target)
```

set_view_save_frame(camera, target, lens)

set_view_save_frame(camera, target, lens, aperture)

set_view_save_frames

set_view_save_frames(cameras::Vector{<:Loc}, targets::Vector{<:Loc})

set_view_save_frames(cameras::Vector{<:Loc}, targets::Vector{<:Loc}, lens::Real)

set_view_save_frames(cameras::Vector{<:Loc}, targets::Vector{<:Loc}, lens::Real, aperture::Real)

set_view_save_frames(cameras::Vector{<:Loc}, targets::Vector{<:Loc}, lenses::Vector{<:Real}, apertures::Vector{<:Real})

set_view_top

```
set_view_top()
```

set_view_top(backends::Tuple{Vararg{Backend}}; backends)

shape_source

```
shape_source(s)
```

show_cs

```
show_cs(p)
```
```
show_cs(p, scale)
```

show_truss_deformation

```
show_truss_deformation()
```
```
show_truss_deformation(results)
```

show_truss_deformation(results, visualizer::Backend; node_radius, bar_radius, factor, deformation_name, deformation_color, no_deformation_name, no_deformation_color)

slab

```
slab()
```
```
slab(region)
```
```
slab(region, level)
```

slab(region, level, family; region, level, family, ref)

slab_family

```
slab_family()
```
```
slab_family(Name::String)
```

slab_family(Name::String, Thickness::Real)

slab_family(Name::String, Thickness::Real, Coating_thickness::Real)

slab_family(Name::String, Thickness::Real, Coating_thickness::Real, Bottom_material::Material)

slab_family(Name::String, Thickness::Real, Coating_thickness::Real, Bottom_material::Material, Top_material::Material)

slab_family(Name::String, Thickness::Real, Coating_thickness::Real, Bottom_material::Material, Top_material::Material, Side_material::Material; name, thickness, coating_thickness, bottom_material, top_material, side_material, based_on, implemented_as, data)

```
slab_family(v::Slab)
```

slab_family_element

```
slab_family_element(family::Family)
```

slab_family_element(family::Family, implemented_as; name, thickness, coating_thickness, bottom_material, top_material, side_material)

slab_level

```
slab_level(v::Slab)
```

slab_region

```
slab_region(v::Slab)
```

slice

```
slice()
```
```
slice(shape)
```
```
slice(shape, p)
```
```
slice(shape, p, n; shape, p, n, ref)
```

slice_n

```
slice_n(v::Slice)
```

slice_p

```
slice_p(v::Slice)
```

slice_ref

slice_ref(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, r::NativeRef{KhepriAutoCAD.ACADKey, Int64}, p::Loc, v::Vec)

slice_ref(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, r::UnionRef{KhepriAutoCAD.ACADKey, Int64}, p::Loc, v::Vec)

slice_shape

```
slice_shape(v::Slice)
```

source_shapes

```
source_shapes(file, line)
```

sph

```
sph(rho::Real, phi::Real, psi::Real)
```

sph(rho::Real, phi::Real, psi::Real, cs::KhepriBase.CS)

sph_phi

```
sph_phi(p::Union{Loc, Vec})
```

sph_psi

```
sph_psi(p::Union{Loc, Vec})
```

sph_rho

```
sph_rho(p::Union{Loc, Vec})
```

sphere

```
sphere()
```
```
sphere(center)
```
```
sphere(center, radius)
```

sphere(center, radius, material; center, radius, material, ref)

sphere_center

```
sphere_center(v::Sphere)
```

sphere_material

```
sphere_material(v::Sphere)
```

sphere_radius

```
sphere_radius(v::Sphere)
```

spline

```
spline()
```
```
spline(v0::Loc, v1::Loc, vs...)
```
```
spline(points)
```
```
spline(points, v0)
```
```
spline(points, v0, v1)
```

spline(points, v0, v1, material; points, v0, v1, material, ref)

spline_material

```
spline_material(v::Spline)
```

spline_path

```
spline_path(vertices::Vector{<:Loc})
```
```
spline_path(v::Loc, vs...)
```

spline_points

```
spline_points(v::Spline)
```

spline_v0

```
spline_v0(v::Spline)
```

spline_v1

```
spline_v1(v::Spline)
```

spotlight

```
spotlight()
```
```
spotlight(loc)
```
```
spotlight(loc, dir)
```
```
spotlight(loc, dir, hotspot)
```

spotlight(loc, dir, hotspot, falloff; loc, dir, hotspot, falloff, ref)

spotlight_dir

```
spotlight_dir(v::Spotlight)
```

spotlight_falloff

```
spotlight_falloff(v::Spotlight)
```

spotlight_hotspot

```
spotlight_hotspot(v::Spotlight)
```

spotlight_loc

```
spotlight_loc(v::Spotlight)
```

start_connection

```
start_connection(b::SocketBackend)
```

start_film

```
start_film(name::String)
```

stroke

stroke(path; material, backend, backends)

stroke_op

stroke_op(b::Backend, op::KhepriBase.LineXThenYOp, start::Loc, curr::Loc, refs)

stroke_op(b::Backend, op::KhepriBase.LineYThenXOp, start::Loc, curr::Loc, refs)

stroke_unite

```
stroke_unite(b::Backend, refs)
```

subpath

subpath(path::CircularPath, a::Real, b::Real)

subpath(path::ArcPath, a::Real, b::Real)

subpath(path::RectangularPath, a::Real, b::Real)

subpath(path::ClosedPolygonalPath, a::Real, b::Real)

subpath(path::OpenPolygonalPath, a::Real, b::Real)

```
subpath(path::Path, a::Real, b::Real)
```

subpath_ending_at

subpath_ending_at(path::OpenPolygonalPath, d::Real)

subpath_ending_at(path::KhepriBase.PathOps, d::Real)

subpath_ending_at(pathOp::LineOp, d::Real)

subpath_ending_at(pathOp::ArcOp, d::Real)

subpath_ending_at(path::Union{ClosedPathSequence, OpenPathSequence}, d::Real)

```
subpath_ending_at(path::Path, d::Real)
```

subpath_starting_at

subpath_starting_at(path::OpenPolygonalPath, d::Real)

subpath_starting_at(path::KhepriBase.PathOps, d::Real)

subpath_starting_at(pathOp::LineOp, d::Real)

subpath_starting_at(pathOp::ArcOp, d::Real)

subpath_starting_at(path::Union{ClosedPathSequence, OpenPathSequence}, d::Real)

subpath_starting_at(path::Path, d::Real)

subpaths

```
subpaths(path::OpenPolygonalPath)
```
```
subpaths(path::ClosedPolygonalPath)
```
```
subpaths(path::Path)
```

subtract_paths

subtract_paths(b::Backend, c_r_w_path, c_l_w_path, c_r_op_path, c_l_op_path)

subtract_paths(path1::ClosedPolygonalPath, path2::ClosedPolygonalPath)

subtract_paths(path1::Path, path2::Path)

subtract_polygon_vertices

```
subtract_polygon_vertices(pts1, pts2)
```

subtract_ref

subtract_ref(b::Backend{K, T}, r0::UnionRef{K, T}, r1::UnionRef{K, T}) where {K, T}

subtract_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::UniversalRef{K, T}) where {K, T}

subtract_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::EmptyRef{K, T}) where {K, T}

subtract_ref(b::Backend{K, T}, r0::EmptyRef{K, T}, r1::GenericRef{K, T}) where {K, T}

subtract_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::UnionRef{K, T}) where {K, T}

subtract_ref(b::Backend{K, T}, r0::UnionRef{K, T}, r1::GenericRef{K, T}) where {K, T}

subtract_ref(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, r0::NativeRef{KhepriAutoCAD.ACADKey, Int64}, r1::NativeRef{KhepriAutoCAD.ACADKey, Int64})

subtract_ref(b::Backend{K, T}) where {K, T}

subtraction

```
subtraction(shape::Shape2D, shapes...)
```
```
subtraction(shape::Shape3D, shapes...)
```

subtraction_shape2D

```
subtraction_shape2D()
```
```
subtraction_shape2D(shape)
```

subtraction_shape2D(shape, shapes; shape, shapes, ref)

subtraction_shape2D_shape

subtraction_shape2D_shape(v::SubtractionShape2D)

subtraction_shape2D_shapes

subtraction_shape2D_shapes(v::SubtractionShape2D)

subtraction_shape3D

```
subtraction_shape3D()
```
```
subtraction_shape3D(shape)
```

subtraction_shape3D(shape, shapes; shape, shapes, ref)

subtraction_shape3D_shape

subtraction_shape3D_shape(v::SubtractionShape3D)

subtraction_shape3D_shapes

subtraction_shape3D_shapes(v::SubtractionShape3D)

sun_pos

sun_pos(date, timezone, latitude, longitude)

sun_pos(year, month, day, hour, minute, Lstm, latitude, longitude)

surface

```
surface()
```
```
surface(c0::Shape, cs...)
```
```
surface(frontier)
```

surface(frontier, material; frontier, material, ref)

surface_arc

```
surface_arc()
```
```
surface_arc(center)
```
```
surface_arc(center, radius)
```

surface_arc(center, radius, start_angle)

surface_arc(center, radius, start_angle, amplitude)

surface_arc(center, radius, start_angle, amplitude, material; center, radius, start_angle, amplitude, material, ref)

surface_arc_amplitude

```
surface_arc_amplitude(v::SurfaceArc)
```

surface_arc_center

```
surface_arc_center(v::SurfaceArc)
```

surface_arc_material

```
surface_arc_material(v::SurfaceArc)
```

surface_arc_radius

```
surface_arc_radius(v::SurfaceArc)
```

surface_arc_start_angle

```
surface_arc_start_angle(v::SurfaceArc)
```

surface_boundary

```
surface_boundary(s::Shape2D)
```

surface_boundary(s::Shape2D, backend::Backend)

surface_circle

```
surface_circle()
```
```
surface_circle(center)
```
```
surface_circle(center, radius)
```

surface_circle(center, radius, material; center, radius, material, ref)

surface_circle_center

```
surface_circle_center(v::SurfaceCircle)
```

surface_circle_material

surface_circle_material(v::SurfaceCircle)

surface_circle_radius

```
surface_circle_radius(v::SurfaceCircle)
```

surface_domain

```
surface_domain(s::SurfaceRectangle)
```
```
surface_domain(s::SurfaceCircle)
```
```
surface_domain(s::SurfaceArc)
```
```
surface_domain(s::SurfaceGrid)
```
```
surface_domain(s::Shape2D)
```

surface_domain(s::Shape2D, backend::Backend)

surface_ellipse

```
surface_ellipse()
```
```
surface_ellipse(center)
```
```
surface_ellipse(center, radius_x)
```

surface_ellipse(center, radius_x, radius_y)

surface_ellipse(center, radius_x, radius_y, material; center, radius_x, radius_y, material, ref)

surface_ellipse_center

surface_ellipse_center(v::SurfaceEllipse)

surface_ellipse_material

surface_ellipse_material(v::SurfaceEllipse)

surface_ellipse_radius_x

surface_ellipse_radius_x(v::SurfaceEllipse)

surface_ellipse_radius_y

surface_ellipse_radius_y(v::SurfaceEllipse)

surface_elliptic_arc

```
surface_elliptic_arc()
```
```
surface_elliptic_arc(center)
```
```
surface_elliptic_arc(center, radius_x)
```

surface_elliptic_arc(center, radius_x, radius_y)

surface_elliptic_arc(center, radius_x, radius_y, start_angle)

surface_elliptic_arc(center, radius_x, radius_y, start_angle, amplitude)

surface_elliptic_arc(center, radius_x, radius_y, start_angle, amplitude, material; center, radius_x, radius_y, start_angle, amplitude, material, ref)

surface_elliptic_arc_amplitude

surface_elliptic_arc_amplitude(v::SurfaceEllipticArc)

surface_elliptic_arc_center

surface_elliptic_arc_center(v::SurfaceEllipticArc)

surface_elliptic_arc_material

surface_elliptic_arc_material(v::SurfaceEllipticArc)

surface_elliptic_arc_radius_x

surface_elliptic_arc_radius_x(v::SurfaceEllipticArc)

surface_elliptic_arc_radius_y

surface_elliptic_arc_radius_y(v::SurfaceEllipticArc)

surface_elliptic_arc_start_angle

surface_elliptic_arc_start_angle(v::SurfaceEllipticArc)

surface_frontier

```
surface_frontier(v::Surface)
```

surface_grid

```
surface_grid()
```

surface_grid(_points::Vector{<:Vector{<:Loc}})

surface_grid(_points::Vector{<:Vector{<:Loc}}, _closed_u)

surface_grid(_points::Vector{<:Vector{<:Loc}}, _closed_u, _closed_v)

surface_grid(_points::Vector{<:Vector{<:Loc}}, _closed_u, _closed_v, _smooth_u)

surface_grid(_points::Vector{<:Vector{<:Loc}}, _closed_u, _closed_v, _smooth_u, _smooth_v)

surface_grid(_points::Vector{<:Vector{<:Loc}}, _closed_u, _closed_v, _smooth_u, _smooth_v, _material; points, closed_u, closed_v, smooth_u, smooth_v, material)

```
surface_grid(points)
```
```
surface_grid(points, closed_u)
```

surface_grid(points, closed_u, closed_v)

surface_grid(points, closed_u, closed_v, smooth_u)

surface_grid(points, closed_u, closed_v, smooth_u, smooth_v)

surface_grid(points, closed_u, closed_v, smooth_u, smooth_v, material; points, closed_u, closed_v, smooth_u, smooth_v, material, ref)

surface_grid_closed_u

```
surface_grid_closed_u(v::SurfaceGrid)
```

surface_grid_closed_v

```
surface_grid_closed_v(v::SurfaceGrid)
```

surface_grid_material

```
surface_grid_material(v::SurfaceGrid)
```

surface_grid_points

```
surface_grid_points(v::SurfaceGrid)
```

surface_grid_smooth_u

```
surface_grid_smooth_u(v::SurfaceGrid)
```

surface_grid_smooth_v

```
surface_grid_smooth_v(v::SurfaceGrid)
```

surface_material

```
surface_material(v::Surface)
```

surface_mesh

```
surface_mesh()
```
```
surface_mesh(vertices)
```
```
surface_mesh(vertices, faces)
```

surface_mesh(vertices, faces, material; vertices, faces, material, ref)

surface_mesh_faces

```
surface_mesh_faces(v::SurfaceMesh)
```

surface_mesh_material

```
surface_mesh_material(v::SurfaceMesh)
```

surface_mesh_vertices

```
surface_mesh_vertices(v::SurfaceMesh)
```

surface_path

```
surface_path()
```
```
surface_path(path; path, ref)
```

surface_path_path

```
surface_path_path(v::SurfacePath)
```

surface_polygon

```
surface_polygon()
```
```
surface_polygon(vertices)
```

surface_polygon(vertices, material; vertices, material, ref)

```
surface_polygon(v0, v1, vs...)
```

surface_polygon_material

surface_polygon_material(v::SurfacePolygon)

surface_polygon_vertices

surface_polygon_vertices(v::SurfacePolygon)

surface_rectangle

```
surface_rectangle()
```
```
surface_rectangle(p::Loc, q::Loc)
```
```
surface_rectangle(corner)
```
```
surface_rectangle(corner, dx)
```
```
surface_rectangle(corner, dx, dy)
```

surface_rectangle(corner, dx, dy, material; corner, dx, dy, material, ref)

surface_rectangle_corner

surface_rectangle_corner(v::SurfaceRectangle)

surface_rectangle_dx

surface_rectangle_dx(v::SurfaceRectangle)

surface_rectangle_dy

surface_rectangle_dy(v::SurfaceRectangle)

surface_rectangle_material

surface_rectangle_material(v::SurfaceRectangle)

surface_regular_polygon

```
surface_regular_polygon()
```
```
surface_regular_polygon(edges)
```
```
surface_regular_polygon(edges, center)
```

surface_regular_polygon(edges, center, radius)

surface_regular_polygon(edges, center, radius, angle)

surface_regular_polygon(edges, center, radius, angle, inscribed)

surface_regular_polygon(edges, center, radius, angle, inscribed, material; edges, center, radius, angle, inscribed, material, ref)

surface_regular_polygon_angle

surface_regular_polygon_angle(v::SurfaceRegularPolygon)

surface_regular_polygon_center

surface_regular_polygon_center(v::SurfaceRegularPolygon)

surface_regular_polygon_edges

surface_regular_polygon_edges(v::SurfaceRegularPolygon)

surface_regular_polygon_inscribed

surface_regular_polygon_inscribed(v::SurfaceRegularPolygon)

surface_regular_polygon_material

surface_regular_polygon_material(v::SurfaceRegularPolygon)

surface_regular_polygon_radius

surface_regular_polygon_radius(v::SurfaceRegularPolygon)

sweep

```
sweep()
```
```
sweep(path)
```
```
sweep(path, profile)
```
```
sweep(path, profile, rotation)
```
```
sweep(path, profile, rotation, scale)
```

sweep(path, profile, rotation, scale, material; path, profile, rotation, scale, material, ref)

sweep_material

```
sweep_material(v::Sweep)
```

sweep_path

```
sweep_path()
```
```
sweep_path(v::Sweep)
```
```
sweep_path(path)
```
```
sweep_path(path, profile)
```
```
sweep_path(path, profile, rotation)
```

sweep_path(path, profile, rotation, scale; path, profile, rotation, scale, ref)

sweep_path_path

```
sweep_path_path(v::SweepPath)
```

sweep_path_profile

```
sweep_path_profile(v::SweepPath)
```

sweep_path_rotation

```
sweep_path_rotation(v::SweepPath)
```

sweep_path_scale

```
sweep_path_scale(v::SweepPath)
```

sweep_profile

```
sweep_profile(v::Sweep)
```

sweep_rotation

```
sweep_rotation(v::Sweep)
```

sweep_scale

```
sweep_scale(v::Sweep)
```

switch_to_backend

switch_to_backend(from::Backend, to::Backend)

switch_to_layer

```
switch_to_layer(layer)
```

switch_to_layer(layer, backends::Tuple{Vararg{Backend}}; backends)

switch_to_layer(to, b::SocketBackend{KhepriAutoCAD.ACADKey, Int64})

table

```
table()
```
```
table(loc::Loc, angle::Real)
```
```
table(loc::Loc, angle::Real, level)
```

table(loc::Loc, angle::Real, level, family::TableFamily)

```
table(loc)
```
```
table(loc, level)
```

table(loc, level, family; loc, level, family, ref)

table_and_chairs

```
table_and_chairs()
```
```
table_and_chairs(loc::Loc, angle::Real)
```

table_and_chairs(loc::Loc, angle::Real, level::Level)

table_and_chairs(loc::Loc, angle::Real, level::Level, family::TableChairFamily)

```
table_and_chairs(loc)
```
```
table_and_chairs(loc, level)
```

table_and_chairs(loc, level, family; loc, level, family, ref)

table_and_chairs_family

table_and_chairs_family(v::TableAndChairs)

table_and_chairs_level

table_and_chairs_level(v::TableAndChairs)

table_and_chairs_loc

```
table_and_chairs_loc(v::TableAndChairs)
```

table_chair_family

```
table_chair_family()
```
```
table_chair_family(Name::String)
```

table_chair_family(Name::String, Table_family::TableFamily)

table_chair_family(Name::String, Table_family::TableFamily, Chair_family::ChairFamily)

table_chair_family(Name::String, Table_family::TableFamily, Chair_family::ChairFamily, Chairs_top::Int64)

table_chair_family(Name::String, Table_family::TableFamily, Chair_family::ChairFamily, Chairs_top::Int64, Chairs_bottom::Int64)

table_chair_family(Name::String, Table_family::TableFamily, Chair_family::ChairFamily, Chairs_top::Int64, Chairs_bottom::Int64, Chairs_right::Int64)

table_chair_family(Name::String, Table_family::TableFamily, Chair_family::ChairFamily, Chairs_top::Int64, Chairs_bottom::Int64, Chairs_right::Int64, Chairs_left::Int64)

table_chair_family(Name::String, Table_family::TableFamily, Chair_family::ChairFamily, Chairs_top::Int64, Chairs_bottom::Int64, Chairs_right::Int64, Chairs_left::Int64, Spacing::Real; name, table_family, chair_family, chairs_top, chairs_bottom, chairs_right, chairs_left, spacing, based_on, implemented_as, data)

table_chair_family_element

table_chair_family_element(family::Family)

table_chair_family_element(family::Family, implemented_as; name, table_family, chair_family, chairs_top, chairs_bottom, chairs_right, chairs_left, spacing)

table_family

```
table_family()
```
```
table_family(Name::String)
```

table_family(Name::String, Length::Real)

table_family(Name::String, Length::Real, Width::Real)

table_family(Name::String, Length::Real, Width::Real, Height::Real)

table_family(Name::String, Length::Real, Width::Real, Height::Real, Top_thickness::Real)

table_family(Name::String, Length::Real, Width::Real, Height::Real, Top_thickness::Real, Leg_thickness::Real)

table_family(Name::String, Length::Real, Width::Real, Height::Real, Top_thickness::Real, Leg_thickness::Real, Material::Material; name, length, width, height, top_thickness, leg_thickness, material, based_on, implemented_as, data)

```
table_family(v::Table)
```

table_family_element

```
table_family_element(family::Family)
```

table_family_element(family::Family, implemented_as; name, length, width, height, top_thickness, leg_thickness, material)

table_level

```
table_level(v::Table)
```

table_loc

```
table_loc(v::Table)
```

tail

```
tail(x::Cons{T}) where T
```

text

```
text()
```
```
text(str)
```
```
text(str, corner)
```
```
text(str, corner, height)
```

text(str, corner, height, material; str, corner, height, material, ref)

text_centered

```
text_centered()
```
```
text_centered(str::String)
```
```
text_centered(str::String, center::Loc)
```

text_centered(str::String, center::Loc, height::Real)

text_corner

```
text_corner(v::KhepriBase.Text)
```

text_height

```
text_height(v::KhepriBase.Text)
```

text_material

```
text_material(v::KhepriBase.Text)
```

text_str

```
text_str(v::KhepriBase.Text)
```

thicken

```
thicken()
```
```
thicken(shape)
```

thicken(shape, thickness; shape, thickness, ref)

thicken_shape

```
thicken_shape(v::Thicken)
```

thicken_thickness

```
thicken_thickness(v::Thicken)
```

to_film

```
to_film(f, name)
```

to_render

```
to_render(f, name)
```

top_aligned_rectangular_profile

```
top_aligned_rectangular_profile()
```

top_aligned_rectangular_profile(Width::Real)

top_aligned_rectangular_profile(Width::Real, Height::Real; width, height)

torus

```
torus()
```
```
torus(center)
```
```
torus(center, re)
```
```
torus(center, re, ri)
```

torus(center, re, ri, material; center, re, ri, material, ref)

torus_center

```
torus_center(v::Torus)
```

torus_material

```
torus_material(v::Torus)
```

torus_re

```
torus_re(v::Torus)
```

torus_ri

```
torus_ri(v::Torus)
```

track_moving_target

```
track_moving_target(camera, targets)
```

track_moving_target(camera, targets, lens)

track_moving_target(camera, targets, lens, aperture)

track_still_target

```
track_still_target(camera_path, target)
```

track_still_target(camera_path, target, lens)

track_still_target(camera_path, target, lens, aperture)

transform

```
transform()
```
```
transform(shape)
```
```
transform(s, p::Loc)
```

transform(shape, xform; shape, xform, ref)

transform_shape

```
transform_shape(v::Transform)
```

transform_xform

```
transform_xform(v::Transform)
```

translate

translate(path::T, v::Vec) where T<:Union{ClosedPathSequence, OpenPathSequence, PathSet, Region}

```
translate(ps::Vector{<:Loc}, v::Vec)
```
```
translate(ss::Vector{<:Shape}, v::Vec)
```

translate(path::KhepriBase.PathOps, v::Vec)

```
translate(s::Circle, v::Vec)
```

translate(path::ClosedSplinePath, v::Vec)

translate(path::ClosedPolygonalPath, v::Vec)

```
translate(path::CircularPath, v::Vec)
```
```
translate(path::ArcPath, v::Vec)
```
```
translate(s::KhepriBase.Text, v::Vec)
```

translate(path::RectangularPath, v::Vec)

translate(path::OpenPolygonalPath, v::Vec)

```
translate(s::Polygon, v::Vec)
```
```
translate(s::Line, v::Vec)
```
```
translate(path::OpenSplinePath, v::Vec)
```

translate(path::KhepriBase.PointPath, v::Vec)

```
translate(sym)
```

translated_cs

translated_cs(cs::KhepriBase.CS, x::Real, y::Real, z::Real)

translating_current_cs

```
translating_current_cs(f)
```
```
translating_current_cs(f, _dx::Real)
```

translating_current_cs(f, _dx::Real, _dy::Real)

translating_current_cs(f, _dx::Real, _dy::Real, _dz::Real; dx, dy, dz)

triangle_area

```
triangle_area(a, b, c)
```

trig_center

```
trig_center(p0, p1, p2)
```

trig_normal

```
trig_normal(p0, p1, p2)
```

truss_analysis

```
truss_analysis()
```
```
truss_analysis(load::Vec)
```

truss_analysis(load::Vec, self_weight::Bool)

truss_analysis(load::Vec, self_weight::Bool, point_loads::Dict)

truss_analysis(load::Vec, self_weight::Bool, point_loads::Dict, backend::Backend; load, self_weight, point_loads, backend)

truss_bar

```
truss_bar()
```
```
truss_bar(p0)
```
```
truss_bar(p0, p1)
```
```
truss_bar(p0, p1, angle)
```

truss_bar(p0, p1, angle, family; p0, p1, angle, family, ref)

truss_bar_angle

```
truss_bar_angle(v::TrussBar)
```

truss_bar_data

truss_bar_data(id::Int64, node0::TrussNodeData, node1::TrussNodeData, rotation::Real, family)

truss_bar_family

```
truss_bar_family()
```
```
truss_bar_family(Name::String)
```

truss_bar_family(Name::String, Radius::Real)

truss_bar_family(Name::String, Radius::Real, Inner_radius::Real)

truss_bar_family(Name::String, Radius::Real, Inner_radius::Real, Material::Material; name, radius, inner_radius, material, based_on, implemented_as, data)

```
truss_bar_family(v::TrussBar)
```

truss_bar_family_element

truss_bar_family_element(family::Family)

truss_bar_family_element(family::Family, implemented_as; name, radius, inner_radius, material)

truss_bar_p0

```
truss_bar_p0(v::TrussBar)
```

truss_bar_p1

```
truss_bar_p1(v::TrussBar)
```

truss_bars

```
truss_bars(ps, qs)
```
```
truss_bars(ps, qs, family)
```

truss_bars_volume

```
truss_bars_volume()
```

truss_bars_volume(backend::Backend; backend)

truss_node

```
truss_node()
```
```
truss_node(p)
```
```
truss_node(p, family; p, family, ref)
```

truss_node_data

truss_node_data(id::Int64, loc::Loc, family, load::Vec)

truss_node_family

```
truss_node_family()
```
```
truss_node_family(Name::String)
```

truss_node_family(Name::String, Radius::Real)

truss_node_family(Name::String, Radius::Real, Support)

truss_node_family(Name::String, Radius::Real, Support, Material::Material; name, radius, support, material, based_on, implemented_as, data)

```
truss_node_family(v::TrussNode)
```

truss_node_family_element

truss_node_family_element(family::Family)

truss_node_family_element(family::Family, implemented_as; name, radius, support, material)

truss_node_is_supported

```
truss_node_is_supported(n)
```

truss_node_p

```
truss_node_p(v::TrussNode)
```

truss_nodes

```
truss_nodes(ps)
```
```
truss_nodes(ps, family)
```

u0

```
u0()
```
```
u0(cs)
```

unhighlight_all_refs

```
unhighlight_all_refs()
```

unhighlight_all_refs(backends::Tuple{Vararg{Backend}}; backends)

unhighlight_all_refs

```
unhighlight_all_refs()
```

unhighlight_all_refs(backends::Tuple{Vararg{Backend}}; backends)

unhighlight_shape

```
unhighlight_shape(s::Shape)
```

unhighlight_shape(s::Shape, backends::Tuple{Vararg{Backend}}; backends)

unhighlight_shapes

```
unhighlight_shapes()
```
```
unhighlight_shapes(ss::Vector{<:Shape})
```

unhighlight_shapes(ss::Vector{<:Shape}, bs)

union

```
union(r::Base.OneTo, s::Base.OneTo)
```
```
union(shape::Shape, shapes...)
```
```
union(shapes::Vector{<:Shape})
```
```
union(s::BitSet, sets...)
```
```
union(s::AbstractSet)
```
```
union(m::KhepriBase.Mesh, ms...)
```

union(A::Pkg.Versions.VersionSpec, B::Pkg.Versions.VersionSpec)

```
union(s, sets...)
```

union_mirror

```
union_mirror()
```
```
union_mirror(shape)
```
```
union_mirror(shape, p)
```

union_mirror(shape, p, n; shape, p, n, ref)

union_mirror_n

```
union_mirror_n(v::UnionMirror)
```

union_mirror_p

```
union_mirror_p(v::UnionMirror)
```

union_mirror_shape

```
union_mirror_shape(v::UnionMirror)
```

union_shape

```
union_shape()
```
```
union_shape(shapes; shapes, ref)
```

union_shape_shapes

```
union_shape_shapes(v::UnionShape)
```

unite_ref

unite_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::UniversalRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::UniversalRef{K, T}, r1::GenericRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::UnionRef{K, T}, r1::UnionRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::EmptyRef{K, T}, r1::EmptyRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::UnionRef{K, T}, r1::EmptyRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::EmptyRef{K, T}, r1::UnionRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::EmptyRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::EmptyRef{K, T}, r1::GenericRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::UnionRef{K, T}, r1::GenericRef{K, T}) where {K, T}

unite_ref(b::Backend{K, T}, r0::GenericRef{K, T}, r1::UnionRef{K, T}) where {K, T}

unite_ref(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64}, r0::NativeRef{KhepriAutoCAD.ACADKey, Int64}, r1::NativeRef{KhepriAutoCAD.ACADKey, Int64})

unite_ref(b::Backend{K, T}) where {K, T}

unitized

```
unitized(v::Vec)
```

universal_shape

```
universal_shape(; ref)
```

unknown

```
unknown()
```
```
unknown(baseref; baseref, ref)
```

unknown_baseref

```
unknown_baseref(v::Unknown)
```

unregister_for_changes

unregister_for_changes(shapes::Vector{<:Shape})

unregister_shape_for_changes

unregister_shape_for_changes(s::Shape, s::Shape)

unregister_shape_for_changes(s::Shape, s::Shape, b::Backend)

upper_level

```
upper_level()
```
```
upper_level(lvl)
```
```
upper_level(lvl, height)
```

used_materials

```
used_materials(b::IOBufferBackend)
```
```
used_materials(s::KhepriBase.BIMShape)
```
```
used_materials(s::Shape)
```
```
used_materials(f::RoofFamily)
```
```
used_materials(f::WallFamily)
```
```
used_materials(f::TableFamily)
```
```
used_materials(f::ChairFamily)
```
```
used_materials(f::WindowFamily)
```
```
used_materials(f::CurtainWallFamily)
```
```
used_materials(f::SlabFamily)
```
```
used_materials(f::BeamFamily)
```
```
used_materials(f::PanelFamily)
```

used_materials(f::CurtainWallFrameFamily)

```
used_materials(f::ColumnFamily)
```
```
used_materials(f::TableChairFamily)
```
```
used_materials(f::DoorFamily)
```

uvx

```
uvx()
```
```
uvx(cs)
```

uvxy

```
uvxy()
```
```
uvxy(cs)
```

uvxyz

```
uvxyz()
```
```
uvxyz(cs)
```

uvxz

```
uvxz()
```
```
uvxz(cs)
```

uvy

```
uvy()
```
```
uvy(cs)
```

uvyz

```
uvyz()
```
```
uvyz(cs)
```

uvz

```
uvz()
```
```
uvz(cs)
```

ux

```
ux()
```
```
ux(cs)
```

uxy

```
uxy()
```
```
uxy(cs)
```

uxyz

```
uxyz()
```
```
uxyz(cs)
```

uxz

```
uxz()
```
```
uxz(cs)
```

uy

```
uy()
```
```
uy(cs)
```

uyz

```
uyz()
```
```
uyz(cs)
```

uz

```
uz()
```
```
uz(cs)
```

vcyl

```
vcyl(rho::Real, phi::Real, z::Real)
```

vcyl(rho::Real, phi::Real, z::Real, cs::KhepriBase.CS)

vertices_center

```
vertices_center(pts)
```

vertices_normal

```
vertices_normal(ps)
```

view_angles

```
view_angles()
```
```
view_angles(lens)
```
```
view_angles(lens, width)
```
```
view_angles(lens, width, height)
```

view_truss_deformation

```
view_truss_deformation()
```
```
view_truss_deformation(results)
```

view_truss_deformation(results, visualizer::Backend; factor)

void_ref

void_ref(b::SocketBackend{KhepriAutoCAD.ACADKey, Int64})

```
void_ref(b::Backend)
```

vpol

```
vpol(rho::Real, phi::Real)
```

vpol(rho::Real, phi::Real, cs::KhepriBase.CS)

vsph

```
vsph(rho::Real, phi::Real, psi::Real)
```

vsph(rho::Real, phi::Real, psi::Real, cs::KhepriBase.CS)

vx

```
vx()
```
```
vx(x::Real)
```
```
vx(x::Real, cs)
```

vxy

```
vxy()
```
```
vxy(x::Real)
```
```
vxy(x::Real, y::Real)
```
```
vxy(x::Real, y::Real, cs)
```

vxyz

```
vxyz(x::Real, y::Real, z::Real)
```

vxyz(x::Real, y::Real, z::Real, cs::KhepriBase.CS)

vxyz(s::StaticArraysCore.SVector{4, Float64}, cs::KhepriBase.CS)

vxz

```
vxz()
```
```
vxz(x::Real)
```
```
vxz(x::Real, z::Real)
```
```
vxz(x::Real, z::Real, cs)
```

vy

```
vy()
```
```
vy(y::Real)
```
```
vy(y::Real, cs)
```

vyz

```
vyz()
```
```
vyz(y::Real)
```
```
vyz(y::Real, z::Real)
```
```
vyz(y::Real, z::Real, cs)
```

vz

```
vz()
```
```
vz(z::Real)
```
```
vz(z::Real, cs)
```

waiting_for_changes

```
waiting_for_changes(s::Shape)
```

waiting_for_changes(s::Shape, b::Backend)

waiting_for_changes(shapes::Vector{<:Shape})

walkthrough

```
walkthrough(path, camera_spread)
```
```
walkthrough(path, camera_spread, lens)
```

walkthrough(path, camera_spread, lens, aperture)

wall

```
wall()
```
```
wall(path)
```
```
wall(path, bottom_level)
```
```
wall(path, bottom_level, top_level)
```

wall(path, bottom_level, top_level, family)

wall(path, bottom_level, top_level, family, offset)

wall(path, bottom_level, top_level, family, offset, doors)

wall(path, bottom_level, top_level, family, offset, doors, windows; path, bottom_level, top_level, family, offset, doors, windows, ref)

wall_bottom_level

```
wall_bottom_level(v::Wall)
```

wall_doors

```
wall_doors(v::Wall)
```

wall_family

```
wall_family()
```
```
wall_family(Name::String)
```

wall_family(Name::String, Thickness::Real)

wall_family(Name::String, Thickness::Real, Left_coating_thickness::Real)

wall_family(Name::String, Thickness::Real, Left_coating_thickness::Real, Right_coating_thickness::Real)

wall_family(Name::String, Thickness::Real, Left_coating_thickness::Real, Right_coating_thickness::Real, Right_material::Material)

wall_family(Name::String, Thickness::Real, Left_coating_thickness::Real, Right_coating_thickness::Real, Right_material::Material, Left_material::Material)

wall_family(Name::String, Thickness::Real, Left_coating_thickness::Real, Right_coating_thickness::Real, Right_material::Material, Left_material::Material, Side_material::Material; name, thickness, left_coating_thickness, right_coating_thickness, right_material, left_material, side_material, based_on, implemented_as, data)

```
wall_family(v::Wall)
```

wall_family_element

```
wall_family_element(family::Family)
```

wall_family_element(family::Family, implemented_as; name, thickness, left_coating_thickness, right_coating_thickness, right_material, left_material, side_material)

wall_offset

```
wall_offset(v::Wall)
```

wall_path

wall_path(b::Backend, path::OpenPolygonalPath, height, l_thickness, r_thickness)

wall_path(b::Backend, path::Path, height, l_thickness, r_thickness)

```
wall_path(v::Wall)
```

wall_top_level

```
wall_top_level(v::Wall)
```

wall_windows

```
wall_windows(v::Wall)
```

window

```
window()
```
```
window(wall)
```
```
window(wall, loc)
```
```
window(wall, loc, flip_x)
```
```
window(wall, loc, flip_x, flip_y)
```

window(wall, loc, flip_x, flip_y, family; wall, loc, flip_x, flip_y, family, ref)

window_family

```
window_family()
```
```
window_family(Name::String)
```

window_family(Name::String, Width::Real)

window_family(Name::String, Width::Real, Height::Real)

window_family(Name::String, Width::Real, Height::Real, Thickness::Real)

window_family(Name::String, Width::Real, Height::Real, Thickness::Real, Right_material::Material)

window_family(Name::String, Width::Real, Height::Real, Thickness::Real, Right_material::Material, Left_material::Material)

window_family(Name::String, Width::Real, Height::Real, Thickness::Real, Right_material::Material, Left_material::Material, Side_material::Material; name, width, height, thickness, right_material, left_material, side_material, based_on, implemented_as, data)

```
window_family(v::Window)
```

window_family_element

```
window_family_element(family::Family)
```

window_family_element(family::Family, implemented_as; name, width, height, thickness, right_material, left_material, side_material)

window_flip_x

```
window_flip_x(v::Window)
```

window_flip_y

```
window_flip_y(v::Window)
```

window_loc

```
window_loc(v::Window)
```

window_wall

```
window_wall(v::Window)
```

with

```
with(f, p, newvalue)
```
```
with(f, p, newvalue, others...)
```

with_beam_family

with_beam_family(f::Function; family, name, profile, material)

with_chair_family

with_chair_family(f::Function; family, name, length, width, height, seat_height, thickness, material)

with_column_family

with_column_family(f::Function; family, name, profile, material)

with_curtain_wall_family

with_curtain_wall_family(f::Function; family, name, max_panel_dx, max_panel_dy, panel, boundary_frame, mullion_frame, transom_frame)

with_curtain_wall_frame_family

with_curtain_wall_frame_family(f::Function; family, name, width, depth, depth_offset, right_material, left_material, side_material)

with_door_family

with_door_family(f::Function; family, name, width, height, thickness, right_material, left_material, side_material)

with_material_as_layer

with_material_as_layer(f::Function, b::Backend, m::Material)

with_panel_family

with_panel_family(f::Function; family, name, thickness, right_material, left_material, side_material)

with_roof_family

with_roof_family(f::Function; family, name, thickness, coating_thickness, bottom_material, top_material, side_material)

with_shape_dependency

```
with_shape_dependency(f, ss)
```

with_slab_family

with_slab_family(f::Function; family, name, thickness, coating_thickness, bottom_material, top_material, side_material)

with_table_chair_family

with_table_chair_family(f::Function; family, name, table_family, chair_family, chairs_top, chairs_bottom, chairs_right, chairs_left, spacing)

with_table_family

with_table_family(f::Function; family, name, length, width, height, top_thickness, leg_thickness, material)

with_transaction

```
with_transaction(fn)
```

with_truss_bar_family

with_truss_bar_family(f::Function; family, name, radius, inner_radius, material)

with_truss_node_family

with_truss_node_family(f::Function; family, name, radius, support, material)

with_wall

```
with_wall(f, args...)
```

with_wall_family

with_wall_family(f::Function; family, name, thickness, left_coating_thickness, right_coating_thickness, right_material, left_material, side_material)

with_window_family

with_window_family(f::Function; family, name, width, height, thickness, right_material, left_material, side_material)

write_obj

write_obj(io::IO, ptss::AbstractMatrix{<:Loc}, closed_u, closed_v, smooth_u, smooth_v, interpolator)

```
x()
```
```
x(x::Real)
```
```
x(x::Real, cs)
```

xy

```
xy()
```
```
xy(x::Real)
```
```
xy(x::Real, y::Real)
```
```
xy(x::Real, y::Real, cs)
```

xyz

```
xyz(x::Real, y::Real, z::Real)
```

xyz(x::Real, y::Real, z::Real, cs::KhepriBase.CS)

xyz(s::StaticArraysCore.SVector{4, Float64}, cs::KhepriBase.CS)

xz

```
xz()
```
```
xz(x::Real)
```
```
xz(x::Real, z::Real)
```
```
xz(x::Real, z::Real, cs)
```

```
y()
```
```
y(y::Real)
```
```
y(y::Real, cs)
```

yz

```
yz()
```
```
yz(y::Real)
```
```
yz(y::Real, z::Real)
```
```
yz(y::Real, z::Real, cs)
```

```
z()
```
```
z(z::Real)
```
```
z(z::Real, cs)
```

zoom_extents

```
zoom_extents()
```

zoom_extents(backends::Tuple{Vararg{Backend}}; backends)

Programação e Computação para Arquitectura